diff options
Diffstat (limited to 'unix/sun')
| -rw-r--r-- | unix/sun/Gterm.hlp | 198 | ||||
| -rw-r--r-- | unix/sun/Imtool.hlp | 420 | ||||
| -rw-r--r-- | unix/sun/Makefile | 67 | ||||
| -rw-r--r-- | unix/sun/README | 5 | ||||
| -rw-r--r-- | unix/sun/arrow.c | 66 | ||||
| -rw-r--r-- | unix/sun/fifo.c | 759 | ||||
| -rw-r--r-- | unix/sun/gterm.c | 1984 | ||||
| -rw-r--r-- | unix/sun/gterm.esc | 46 | ||||
| -rw-r--r-- | unix/sun/gterm.h | 18 | ||||
| -rw-r--r-- | unix/sun/gterm.icon | 34 | ||||
| -rw-r--r-- | unix/sun/gterm.icon.OLD | 34 | ||||
| -rw-r--r-- | unix/sun/gterm.man | 784 | ||||
| -rw-r--r-- | unix/sun/gtermio.c | 1224 | ||||
| -rw-r--r-- | unix/sun/halley.lut | 257 | ||||
| -rw-r--r-- | unix/sun/heat.lut | 257 | ||||
| -rw-r--r-- | unix/sun/imtool.c | 4488 | ||||
| -rw-r--r-- | unix/sun/imtool.cross | 4 | ||||
| -rw-r--r-- | unix/sun/imtool.cursor | 4 | ||||
| -rw-r--r-- | unix/sun/imtool.h | 13 | ||||
| -rw-r--r-- | unix/sun/imtool.icon | 66 | ||||
| -rw-r--r-- | unix/sun/imtool.icon.NEW | 34 | ||||
| -rw-r--r-- | unix/sun/imtool.man | 713 | ||||
| -rw-r--r-- | unix/sun/imtool.square | 4 | ||||
| -rw-r--r-- | unix/sun/imtoolrc | 48 | ||||
| -rwxr-xr-x | unix/sun/mksuntool.csh | 39 | ||||
| -rw-r--r-- | unix/sun/mouse.c | 47 | ||||
| -rw-r--r-- | unix/sun/notify_read.c | 85 | ||||
| -rw-r--r-- | unix/sun/screendump.c | 549 | ||||
| -rw-r--r-- | unix/sun/ss1.patch | 31 |
29 files changed, 12278 insertions, 0 deletions
diff --git a/unix/sun/Gterm.hlp b/unix/sun/Gterm.hlp new file mode 100644 index 00000000..d97b4407 --- /dev/null +++ b/unix/sun/Gterm.hlp @@ -0,0 +1,198 @@ +.help gterm Dec86 "Vector Graphics for the Sun Workstation" +.sp 2 +.ce +\fBVector Graphics for IRAF on the Sun Workstation\fR +.ce +Doug Tody +.ce +December, 1986 +.ce +(design document) +.sp 3 +.NH +Graphics Terminal Model + + The window based, native vector graphics facility for Sun/IRAF will be +implemented as a purely data driven interface based on the concept of an +intelligent virtual graphics terminal. The virtual graphics terminal will +be implemented in software as a process running under a window system such +as Sunview or X. + +A virtual terminal interface will allow the Sun workstation to be used as an +ordinary graphics terminal to access IRAF or other software on either the +local or a foreign host via any data stream interface, e.g., rlogin, telnet, +or a modem connection. For example, one will be able to use telnet running +in a GTERM window to login on a VMS machine, then run IRAF on the VMS machine +in the normal fashion. Conversely, since the IRAF software on the Sun node +will always think that it is talking to a conventional data driven graphics +terminal, the Sun/IRAF software may in fact be run from a conventional +graphics terminal, via either a direct or remote login. Finally, a pure data +stream TTY interface where all details of the windowing system are isolated +into a server process makes it possible for a single version of IRAF to support +multiple window systems on the same host. + +The graphics terminal to be implemented by GTERM shall consist of independent +text and graphics frames. These will be implemented as separate windows +(frames) under SunView, allowing them to be moved, resized, exposed, hidden, +open, closed, etc., independently of each other. Note however that since both +frames are connected to the controlling process via a single terminal i/o +connection, the controlling process (e.g., the CL) can only read from or +write to one frame at a time. + +In normal use, the user will work for a time in the text frame, issuing +commands to run tasks which do not require interactive graphics facilities. +When a graphics program is run the graphics frame will be opened or exposed +and the plot drawn. If the graphics program is interactive, i.e., uses +cursor input, the cursor will be moved to the center of the window and the +crosshairs turned on to indicate that cursor input is required. A sequence +of keystroke or mouse button triggered cursor reads will follow, and +eventually graphics mode will be exited by transmission of the close +workstation sequence to GTERM by GIO running in the applications program. + +When graphics mode is exited GTERM terminal i/o is redirected to the text +frame and the cursor is restored to its former position in the text frame, +automatically restoring interactive control to the text frame. The graphics +frame may or may not be closed or hidden, depending upon the GTERM defaults +set up by the user. If the graphics frame is to be closed or hidden this +should probably require interactive confirmation by the user, else the plot +might disappear immediately after being drawn. Since control naturally +toggles back and forth between the text and graphics frames and since screen +space is always limited and a large, high resolution graph is generally +desired, it is expected that the graphics frame will normally be displayed +only while in graphics mode. + +.NH +GTERM Graphics Language + + The tektronix graphics language is a simple and efficient standard language +for graphics terminal i/o which will work about as well as anything in our +application. In particular, the vector encoding scheme is simple, compact and +efficient, and well suited to use with a variety of terminal drivers and +modems (since binary data is avoided). The best approach to implementing the +GTERM graphics language would seem to be to take the tektronix language as a +starting point and add additional functionality by extending the language +with new control sequences. Some of the extensions defined here a taken from +the Retrographics vt640 and the Pericom. Others more specific to window based +applications will be added in the future in an upwards compatible fashion. + + +.ks +.nf + GS open workstation if not already open + open/expose graphics frame (icon -> full window) + direct terminal i/o to graphics frame + save cursor (mouse) position + issue GS dark vector command (see below) + CAN close workstation + restore control to text frame (restore cursor) + close/hide graphics frame (full window -> icon) + keystroke required to trigger close-window? + + + GS (workstation already opened) + enter vector drawing mode, dark vector + FS enter point plot mode + US,CR enter alpha mode + text is drawn in graphics frame + defaults to transparent text, erase permitted + ESC CR enter text mode + lines of text are drawn on status line in + nontransparent (overwrite) mode + + ESC SUB enter crosshair mode + ESC FF clear screen, initialize drawing modes + ESC/f [x,y] set crosshair position + GS [x,y] US sets alpha cursor position + + ESC[0123] set character size (normal,2x,3x,4x) + ESC[`abcd] set line drawing style (normal,dotted,dotdash,sd,ld) + ESC/[012]d set drawing mode (set, clear, toggle) + ESC/[0123]w set polyline linewidth (normal,2x,3x,4x) + + Standard screen resolution is 1024 by 780. + In graphics mode, chars are interpreted as [x,y] coordinate pairs. + In alpha mode, chars are interpreted as characters to be drawn. +.fi +.ke + + +A number of extensions to this basic language are being considered for future +implementation. Support for color, multiple text fonts, general polymarkers, +area fill, and possibly cell array are contemplated, as well as simple +extensions for window control and pop-down menus. Support for the standard +textronix features which have been omitted (vector point elimination, +incremental point mode, status enquiry) is possible. The interface is easily +extensible hence there is no need to attempt to define or support such features +in the initial interface. + +.NH +Implementation Notes + + The GTERM virtual terminal consists of two independent frames, the text +frame and the graphics frame. Selection of the frame to which output is to +be delivered is done at the lowest possible level, i.e., when the read system +call is issued by the terminal to accept terminal output from the pty +(pseudo-terminal driver) stream for the terminal. This is done by linking in +a custom version of the notify_read() primitive, the low level read primitive +for notifer based programs. Output is initially to the text frame. Output +is redirected to the graphics frame when GS is seen in the output stream, +and later restored to the text frame when CAN is seen. Input is controlled +independently by the two frames at a high level, hence does not have to be +switched. + +All terminal operations are event driven. Graphics data is deposited into a +circular input buffer by an event driven read routine, which can issue +<ctrl/s>/<ctrl/q> to the terminal driver to control the rate at which input +is accumulated. A separate drawing routine running off an interval timer +is used to process data appearing in the input buffer. The drawing code is +always in one of three modes: vector drawing mode, alpha mode (randomly +addressable character drawing), or text mode (textual output to the status +line). + +.SH +Appendix: Tektronix Graphics Language (Retrographics vt640) + +.ks +.nf + *GS enter graphics mode; dark vector + *FS enter point plot mode + RS enter incremental point mode + *US,CR enter alpha mode, graphics plane, tek font + CAN disable graphics mode, restore output to terminal plane + + ESC"0g alias for enter transparent mode + ESC"4g alias for enter crosshair mode + ESC"5g enter light pen mode + + *ESC SUB enter crosshair mode + *ESC FF clear screen, initialize drawing modes + *ESC ENQ return cursor position, other status + + ESC[0123] set character size (normal,2x,3x,4x) + ESC[`abcd] set line drawing style (normal,dotted,dotdash,sd,ld) + ESC/[012]d set drawing mode (set, clear, toggle) + + ESC/f set crosshair position + *GS [x,y] US sets alpha cursor position + + Vector coordinate encoding (max 10 bits = 1024 points res.): + + high y P01XXXXX + low y P11XXXXX + high x P01XXXXX + low x P10XXXXX + + Cursor return structure: + + key PXXXXXXX + high x P01XXXXX + low x P01XXXXX + high y P01XXXXX + low y P01XXXXX + trailer <cr> + + Standard 4010/4012 screen resolution is 1024 by 780. + In graphics mode, chars are interpreted as [x,y] coordinate pairs. + In alpha mode, chars are interpreted as characters to be drawn. +.fi +.ke diff --git a/unix/sun/Imtool.hlp b/unix/sun/Imtool.hlp new file mode 100644 index 00000000..39d42dbe --- /dev/null +++ b/unix/sun/Imtool.hlp @@ -0,0 +1,420 @@ +.help imtool Jan87 "Image Display on the Sun Workstation" +.sp 3 +.ce +\fBImage Display on the Sun Workstation\fR +.ce +Design Specification (prototype display) +.ce +Doug Tody +.ce +January 1987 + +.NH +Introduction + + This document describes the prototype Sunview based SUN/IRAF image display. +The standard Sun-3 color workstation provides an 1152 by 900 by 8 bit frame +buffer (some models are larger) with an associated 256 entry color table and +an RGB display. A keyboard and a three button mouse are provided for +interactive control and command entry. + +In typical interactive use the user will have a number of windows open on the +screen, e.g., a GTERM virtual graphics terminal with text and graphics windows, +the image display window, a small console window, and several icons. +Due to limitations on the amount of screen space available and due to speed +limitations when refreshing a full 8 bit deep window, it is desirable to limit +the size of the image display window to a fraction of the screen space most +of the time. + +Due to the complexity of the task of designing a fully functional, device +independent image display interface, and the need to get at least a basic +image display capability functioning for SUN/IRAF as soon as possible, +a prototype display will be implemented first in January 1987 followed by +the full interface later in the year. Although the prototype will not provide +full functionality or system and device independence, the basic features are +expected to be provided im much the same form that they will take in the final +interface. + +.NH +User Interfaces + + The prototype image display will use the existing TV/DISPLAY program to +load images into the image display. None of the other tasks in the TV package +will be supported and the entire contents of the TV package will disappear +later this year. Display interaction and cursor readback will be via the +same cursor mode interface currently used for the graphics terminal interface. +Additional display-level interaction will be available under mouse control, +e.g., to support display dependent functions not otherwise supported in cursor +mode, such as greyscale windowing, filtering (resampling), region of interest +control, and the like. + +.NH +Display Features +.NH 2 +Image and Graphics Planes + + The display size is a setup configuration parameter but is fixed while the +display is in use. Typical display sizes might be 512, 800, 1024, or 2048 +pixels square, or some rectangular size. Sufficient physical memory should be +available so that the internal frame buffers may be locked into memory. + +The image display will be 7 bits deep with 1 bit of graphics +overlay, leaving half of the color table entries for use by other +graphics windows. The image may be windowed without affecting the +color table entries of the other windows on the screen. If 7 bits +of greyscale proves to be a serious limitation something on the order +of 7.9 bits is possible by playing tricks with the software (clever +use of the color table). This latter feature will not be available +in the initial prototype. + +The prototype display will provide N image frames, all of which must be the +same size, each with its own independent lookup table and viewport. +The frame size and number of frames are arbitrary and will be a setup option. +Blinking, split screen, true color representation, and other operations +involving simultaneous display of multiple frames will not be implemented +n the prototype display. + +The full display will support N image frames, each with an associated 1 bit +graphics overlay, with all frame-graphics pairs the same size, and with +support for multiple screen operations such as blink and split screen. +Independent lookup tables will not be possible in split screen mode, +but this may not be a serious problem given the autoscaling algorithm in +the DISPLAY task, and the possibility of normalization of multiple image +frames to use a common lookup table (by modifying the loaded pixel values), +once the lookup table has been independently adjusted for each frame. + +.NH 2 +Pseudocolor and True Color + + Pseudocolor will probably not be supported in the initial prototype, +although it may be added to the prototype before the final interface is written. +True color can probably be provided in the final interface by maintaining an +independent lookup table for each of the three frames (RGB) in software, +generating the compound output in software, and displaying the result in +hardware using a software generated linear pseudocolor lookup table. Once the +true color image is generated all of the zoom, pan, etc. functions will work +with their usual speed. Since true color display is used infrequently (and +fully buffered memory to memory operations are fairly fast anyhow) this +technique should prove quite adequate. + +.NH 2 +The Display Window + + The user views the displayed image through a window which may be resized and +moved about on the screen at any time, under interactive control of the mouse. +Resizing the window changes only the size of the subraster of the fixed-size +image frame to be displayed. Moving the window under Sunview does not change +the window into the image, merely the position of the image display window on +the screen. + +Zoom and pan is implemented in software. Zoom is implemented by pixel +replication and dezoom by pixel subsampling, operating simultaneously on both +the greyscale and graphics planes. Each operation results in a reload of the +portion of the image displayed in the image window from data stored in the +fixed size internal frame buffer. Zoom, dezoom, and roam are controlled +interactively using either the normal cursor mode keystrokes (ZXYEP,1-9M,0), +the mouse, or both. + +Once the region of interest has been adjusted on the display via the full pixel +sampling techniques, a "resample" operation may be performed to recompute the +contents of the displayed subraster using block averaging and/or bilinear +interpolation techniques. A possible variation on this is to compute several +block averaged versions of the full image at various dezoom factors, e.g., +2, 4, and 8 times dezoom, and read from these rather than the full frame when +dezoom is selected. For example, if the frame size is 2048 square, the display +would simultaneously store 2048, 1024, 512, and 256 square block-averaged +versions of the frame and dynamically select the version to be used depending +upon the dezoom factor. The percentage of additional memory required to hold +the dezoomed frames is only about 40% greater than the fully sampled frame. +Timing tests need to be performed to see if this is worthwhile. + +.NH 2 +Region of Interest + + Due to screen space limitations the image window will rarely exceed about +512 square pixels in size, hence one will normally view either a dezoomed +version of the image or a subraster of the full frame (full screen display +will of course be an option). One possible way to live with dezoom without +suffering loss of resolution is to use an icon, e.g., 64 pixels square, +to always display the region under the cursor at full resolution or better. +The display would consist of, for example, a 512 square main window displaying +the dezoomed image, and an independently movable 64 square by 8 bit icon +displaying an enlarged version of the image cursor, crosshairs, graphics +overlay, and all. + +Alternatively, the cursor could be positioned on the full window and then a +mouse button pressed to display the cursor at full resolution (or better), +at the position of the cursor, with the display returning to normal when the +mouse button is released. Yet another possibility is for the cursor to act +as a magnifier which is moved about over the dezoomed image. Most probably +all these choices will be provided as options, since they are all variations +on the same thing. + +.NH 2 +Windowing + + The lookup tables will be readable and writable under software control for +sophisticated applications such as interactive entry of a piecewise linear +transfer function. Most commonly, however, greyscale windowing will be +performed by the image display under control of the mouse. The most attractive +way to do this is probably to display a histogram of the image in the graphics +plane, overlaid by the current transfer function, which typically looks like +this: + +.ks +.nf + /------------ + / + / + ---------/ +.fi +.ke + +Moving the cursor to the left will lower the threshold (move the displayed +curve to the left), and moving the cursor up will increase the contrast +(increase the slope of the transfer function). Ideally window mode would +be entered by pressing a mouse button (or some combination of a mouse button +and a control or shift key), windowing performed with the mouse button held +down, and window mode exited when the mouse button is released. + +.NH 2 +Reading the Cursor + + The image display cursor may be any 64 pixel square object with a shape +which is suitable for centering on two dimensional objects. The default cursor +will be a pair of 64 pixel long crosshairs with a gap in the middle. When a +cursor read is in progress the cursor will blink rapidly, e.g., at 4-8 Hz, +signaling to the user that the program is waiting for a cursor read (this is +like turning on the full crosshairs on the GTERM graphics screen). The cursor +may be moved either with the mouse or with the HJKL keys in cursor mode. +A cursor read will be terminated by typing a key on the keyboard, or by +pressing a mouse button which has been aliased to a key (as in GTERM). + +All cursor input will be via the standard IRAF cursor mode cursor input +facility. The result of an image cursor read will be a line of text identical +to that returned for a graphics cursor read, i.e., containing the cursor +position in world coordinates (image pixel coordinates in this case), the +WCS number, the key typed, and so on. Semi-automatic readout of the image +cursor coordinates may be obtained via the "C" function in cursor mode, +perhaps aliased to a mouse button. + +.NH 2 +Hardcopy Output + + While there will be no snap/crtpict support initially, it will be possible +to get pseudo-greyscale output hardcopy on the laserwriter via menu selection, +as in GTERM, by taking advantage of the greyscale rendering capabilities of +Postscript and the 300 dpi resolution of the laserwriter. It also should be +possible to use :.snap or "=" to get hardcopy output in cursor mode. + +.NH +Features Not Supported + + The prototype display will provide as IRAF callable functions only image +frame buffer i/o, screen clear, viewport control (zoom/pan), and read and write +cursor position. Greyscale windowing, hardcopy output, and window resize and +move will be handled directly by the image display and Sunview, under mouse +control. Initially there will be no access to the graphics overlay, and only +monochrome display will be supported (pseudocolor may be added to the prototype +at some point). Full functionality will follow when the GIO imaging extensions +and IDI interface specification have been completed. + +.NH +Implementation + + The following subsystems need to be added or modified to implement the +prototype SUN/IRAF Sunview image display. +.ls +.ls [1] +The software image display program (new code). This will be implemented as +a Sunview tool (process), to be linked into the "basetools" executable (where +GTERM lives). The image display process (or processes if there are multiple +displays) will communicate with other processes via sockets and/or shared +memory. A special file entry will be required in /dev for each display +pseudo-device. The Sunview server process will normally be set up when the +user's .suntools file is interpreted, but will not be displayed until the +display is first loaded. Commands and data will be passed between the server +process and the client (e.g.,some IRAF process) via the conventional socket +based IPC mechanism and an application defined RPC mechanism. Shared memory +will be used to eliminate pixel i/o to the image frame buffers when the server +resides on the same machine as the client. +.le +.ls [2] +The low level code in the DISPLAY program must be modified to talk with the +display server. For the prototype, this is probably best done using the FIO +based display interface rather than GIO, since the current display program +is written to use FIO. The display task will directly read and write the +display server frame buffer using the Sys V shared memory facilities. The +final interface will do the same (or use a socket if the server is on a remote +machine), but will use the more flexible GIO interface. The DISPLAY task +must also be modified to compute the WCS and output it to the cursor mode +code via GIO, in order for cursor readback to function. +.le +.ls [3] +Cursor mode must be modified to support cursor input from imaging devices. +The principle modification seems to be the addition of a set device viewport +instruction, to be used to pass zoom and pan instructions on to the device +kernel rather than implementing them directly in the cursor mode software as +is done for the STDGRAPH devices. The open / close workstation, activate / +deactivate workstation, clear screen, set cursor, and get cursor functions +are also needed, but need not be different than the equivalent STDGRAPH +functions. +.le +.le + +Cursor mode requires implementation of some portion of a GIO device interface +for the image display. Probably this will be implemented using an inline +kernel, at least for the prototype display. Both the GIO kernel and the +DISPLAY task will communicate directly with the display server via IPC. + +.NH 2 +Display Control Interface + + Applications programs such as the DISPLAY task or the CL cursor mode code +will access the display via IPC carrying a GKI command and data stream. Most +of the GKI instructions used are already provided by the current GIO/GKI +interface. These are summarized below for reference. + + +.ks +.nf + GKI_EOF = BOI 0 L +* GKI_OPENWS = BOI 1 L M N D +* GKI_CLOSEWS = BOI 2 L N D +* GKI_REACTIVATEWS = BOI 3 L +* GKI_DEACTIVATEWS = BOI 4 L +* GKI_MFTITLE = BOI 5 L N T +* GKI_CLEARWS = BOI 6 L + GKI_CANCEL = BOI 7 L + GKI_FLUSH = BOI 8 L + GKI_POLYLINE = BOI 9 L N P + GKI_POLYMARKER = BOI 10 L N P + GKI_TEXT = BOI 11 L P N T + GKI_FILLAREA = BOI 12 L N P +* GKI_PUTCELLARRAY = BOI 13 L LL UR NC NL P +* GKI_SETCURSOR = BOI 14 L CN POS + GKI_PLSET = BOI 15 L LT LW CI + GKI_PMSET = BOI 16 L MT MW CI + GKI_TXSET = BOI 17 L UP SZ SP P HJ VJ F Q CI + GKI_FASET = BOI 18 L FS CI +* GKI_GETCURSOR = BOI 19 L CN + GKI_CURSORVALUE = BOI 19 L CN POS KEY +* GKI_GETCELLARRAY = BOI 20 L LL UR NC NL + GKI_CELLARRAY = BOI 20 L NP P + GKI_ESCAPE = BOI 25 L FN N DC + GKI_SETWCS = BOI 26 L N WCS + GKI_GETWCS = BOI 27 L N +.fi +.ke + + +Those instructions which are required in the prototype interface are marked +with an asterisk. In addition we need a number of new instructions to +perform various common image display control functions. This is the topic +of the GIO imaging extensions project, which we do not wish to attempt to +seriously address in the prototype display. The new GKI instructions outlined +in the remainder of this section are intended only to permit the implementation +of the prototype SUN image display, and will be replaced by a full and much +more carefully defined set of instructions when the full interface is designed. + +A new instruction is needed to set the device viewport, i.e., the portion of +the frame buffer to be displayed in the display window. The set viewport +instructions are used to implement zoom and pan at the cursor level. + + +.ks +.nf + GKI_SETVIEWPORT = BOI 28 L XC YC ZX ZY + GKI_GETVIEWPORT = BOI 29 L XC YC ZX ZY + GKI_VIEWPORT = BOI 29 L XC YC ZX ZY +.fi +.ke + + +The device viewport is specified by the [x,y] center of the displayed area in +frame buffer pixel coordinates (1-indexed), and the zoom or dezoom factor in +each axis. This representation is used, rather than specifying the corner +points of the intended viewport, so that the viewport may be specified +independently of the size of the actual device window used, and to avoid +questions about what happens near the edge of the frame. + +Instructions are also needed to set and inquire the index of the frame +currently being displayed, and the index of the reference frame for the i/o +and control functions; these need not be the same frame. + + +.ks +.nf + GKI_SETFRAME = BOI 30 L RF DF + GKI_GETFRAME = BOI 31 L + GKI_FRAME = BOI 31 L RF DF +.fi +.ke + + +Here, RF is the index of the reference frame, i.e., the frame to be operated +upon or referenced in all set, get, and pixel i/o operations, and DF is the +index of the frame currently being displayed or to be displayed. The frames +are numbered 1, 2, ..., N; 0 indicates that the reference frame or display +frame is not to be changed. + +The concept of the display frame is important in cursor reads. In a cursor +read or write operation, a CN (cursor number) index of 0 indicates that the +cursor of the display frame is to be referenced; the index of the frame +actually referenced will be returned in the CN field of the cursor value +structure. If a nonzero CN is given the cursor of the indicated frame is +referenced, whether or not the indicated reference frame is currently +displayed. + +Lastly, we need an inquiry function to determine the size and depth of the +image frame buffer, and the number of image planes. It is assumed that the +frame buffer size, etc., will be set up in advance by the user, either using +the mouse and the display setup panel, or via command line arguments in the +.suntools file when the display server is initially spawned. + + +.ks +.nf + GKI_GETFRAMESIZE = BOI 32 L + GKI_FRAMESIZE = BOI 32 L NP NX NY NZ +.fi +.ke + + +Here, NP is the number of image planes, NX and NY are the size in pixels of +each image plane, and NZ is the number of displayable greylevels, e.g., 256. +Note that NZ need not be a power of two as the entire colortable may not be +available. + +The image display will be a standard GIO (inline or sub) kernel down to the +level where some action occurs, after decoding the i/o instruction to be +executed. At that point a device dependent C subroutine will be called which +will pass the command on to the display server, which will always reside in a +separate process (it has to, due to the peculiar notifier based nature of the +Sunview environment). + +.NH 2 +Display Internals + + The primary functions of the display server are [1] to maintain a frame +buffer, and respond to requests to display portions of the frame buffer in the +display window at some zoom or dezoom factor, and [2] to read and execute +commands from a client process. + +Case [1] includes both refresh of the primary window, which occurs whenever a +new image is loaded, the device viewport changes, or the window is resized or +uncovered, and refresh of the region of interest (cursor) window, which occurs +whenever any of the above events occurs or whenever the cursor is moved. +In fact it appears that both operations are really the same thing, except that +the cursor window always hides the main window, has a narrower border and no +label, and is refreshed more often than the main window. The refresh operation +sets up a mapping between the frame buffer and a window and then either does +a series of pixrect operations to refresh the window (which may be partially +or fully covered), or carries out a resampling operation on a region of the +frame buffer, writing the zoomed or dezoomed data to the display window. + +The commands to be executed in case [2] are the GKI functions described in the +previous section. In the prototype display the primary commands are open / +close workstation, set viewport, set cursor position, and read cursor. +The set viewport function merely sets up a transformation and calls the +window refresh code described in the previous paragraph. diff --git a/unix/sun/Makefile b/unix/sun/Makefile new file mode 100644 index 00000000..029b957e --- /dev/null +++ b/unix/sun/Makefile @@ -0,0 +1,67 @@ +# Make the Sunview GTERM graphics terminal server, IMTOOL image display server. + +SRCS= arrow.c mouse.c notify_read.c screendump.c +OBJS= arrow.o mouse.o notify_read.o screendump.o +LIBS= -lsuntool -lsunwindow -lpixrect -lm +SUNOBJS= imtool.o gterm.o gtermio.o screendump.o arrow.o mouse.o notify_read.o + +# Set the following to "-f68881" on a Sun-3, to "" on a Sun-4 or 386i. +#FLOAT= -f68881 +FLOAT= + +# Make the custom suntools executable only on versions of SunOS prior to 4.0. +default: + sh -c 'if [ "`grep Release.4 /etc/motd`" != ""\ + -o `mach` = "i386" ]; then\ + make gterm.e; make imtool.e;\ + else\ + make suntools.e;\ + fi' + +# Make a custom SUNTOOLS with GTERM, IMTOOL, linked in. +suntools.e: gterm.c imtool.c gtermio.o $(OBJS) + chmod +x mksuntool.csh; mksuntool.csh + cc -c -O $(FLOAT) gterm.c imtool.c + mv -f gterm.o imtool.o suntool + cp gtermio.o $(OBJS) suntool + (cd ./suntool; make basetools MOREOBJS="$(SUNOBJS)" CPUFLAG="" ;\ + mv -f suntools ../suntools.e) + +# Make the GTERM test executable. +gterm.e: gterm.o gtermio.o $(OBJS) + cc $(FLOAT) gterm.o gtermio.o $(OBJS) $(LIBS) -o gterm.e + +# Make the IMTOOL test executable. +imtool.e: imtool.o $(OBJS) + cc $(FLOAT) imtool.o $(OBJS) $(LIBS) -o imtool.e + +# Install the executables in iraf$local, which is where the INSTALL script +# expects to find it. + +install: + strip *.e; mv -f *.e $$iraf/unix/bin.`mach` + +clean: + rm -f *.[aoe] + rm -rf suntool + +gterm.o: gterm.c gterm.h gterm.icon + cc -c -O -DSTANDALONE $(FLOAT) gterm.c + +imtool.o: imtool.c imtool.h imtool.icon imtool.cursor + cc -c -O -DSTANDALONE $(FLOAT) imtool.c + +gtermio.o: gtermio.c gterm.h gterm.esc + cc -c -O $(FLOAT) gtermio.c + +arrow.o: arrow.c + cc -c -O $(FLOAT) arrow.c + +mouse.o: mouse.c + cc -c -O $(FLOAT) mouse.c + +notify_read.o: notify_read.c + cc -c -O $(FLOAT) notify_read.c + +screendump.o: screendump.c + cc -c -O $(FLOAT) screendump.c diff --git a/unix/sun/README b/unix/sun/README new file mode 100644 index 00000000..4196b336 --- /dev/null +++ b/unix/sun/README @@ -0,0 +1,5 @@ +GTERM -- Graphics terminal emulator. +IMTOOL -- Image display server. + +See gterm.man, imtool.man for detailed documentation. +This software is installed by the $iraf/unix/hlib/install script. diff --git a/unix/sun/arrow.c b/unix/sun/arrow.c new file mode 100644 index 00000000..1cc55aad --- /dev/null +++ b/unix/sun/arrow.c @@ -0,0 +1,66 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <sys/types.h> +#include <sundev/kbio.h> +#include <sundev/kbd.h> + +/* + * ARROW.C -- Code to enable and disable the arrow key function-key mappings + * (R8,10,12,14). + */ + +#define NKEYS 4 +static unsigned char station[NKEYS] = { 0x45, 0x5b, 0x5d, 0x71 }; +static unsigned char entry[NKEYS] = { RF(8), RF(10), RF(12), RF(14) }; +static struct kiockey o_key[NKEYS]; + + +/* DISABLE_ARROW_KEYS -- Save the arrow key keyboard translation table + * entries, and then disable the mapping of the function keys to the ANSI + * arrow key sequences. This is necessary to read the function key as + * an event rather than an escape sequence in a Sunview event handler. + */ +disable_arrow_keys() +{ + register int fd, i; + struct kiockey key; + int status = 0; + + if ((fd = open ("/dev/kbd", 2)) == -1) + return (-1); + + for (i=0; i < NKEYS; i++) { + o_key[i].kio_station = station[i]; + if ((status = ioctl (fd, KIOCGETKEY, &o_key[i])) != 0) + break; + key = o_key[i]; + key.kio_entry = entry[i]; + if ((status = ioctl (fd, KIOCSETKEY, &key)) != 0) + break; + } + + close (fd); + return (status); +} + + +/* ENABLE_ARROW_KEYS -- Restore the saved arrow key keyboard translation table + * entries. + */ +enable_arrow_keys() +{ + register int fd, i; + struct kiockey key; + int status = 0; + + if ((fd = open ("/dev/kbd", 2)) == -1) + return (-1); + + for (i=0; i < NKEYS; i++) + if ((status = ioctl (fd, KIOCSETKEY, &o_key[i])) != 0) + break; + + close (fd); + return (status); +} diff --git a/unix/sun/fifo.c b/unix/sun/fifo.c new file mode 100644 index 00000000..65471a77 --- /dev/null +++ b/unix/sun/fifo.c @@ -0,0 +1,759 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <sys/types.h> +#include <sys/time.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <signal.h> +#include <ctype.h> +#include <stdio.h> + +#define SUNOS4 + +/* + * FIFO.C -- Test fifo i/o. This is a server process much like IMTOOL, + * except that all the process does is respond to datastream requests + * to read and write an internal 512 sq frame buffer maintained as an + * array in memory (only one frame buffer is supported). A log is kept + * to the stderr of all datastream requests. + * + * Used to debug fifo i/o - NOT USED IN THE ONLINE PROGRAMS. + * + * To make: cc fifo.c -o fifo.e + * + * Usage: fifo.e >& spool run server, logging output to spool + * fifo.e -i run interactively + * + * In interactive mode, cursor value strings may be typed in on the fifo.e + * stdin in response to cursor read requests from the client. Otherwise, + * a constant cursor value "1.0 1.0 101 q" is returned. + */ + +#define I_DEVNAME "/dev/imt1o" +#define O_DEVNAME "/dev/imt1i" +#define OLD_DEVNAME "/dev/imt1" +#define IO_TIMEOUT 30 +#define SZ_FIFOBUF 4000 +#define SZ_WCSBUF 320 /* WCS text buffer size */ +#define MAX_FRAMES 1 +#define SZ_FNAME 256 + +#define MEMORY 01 /* frame buffer i/o */ +#define LUT 02 /* lut i/o */ +#define FEEDBACK 05 /* used for frame clears */ +#define IMCURSOR 020 /* logical image cursor */ +#define WCS 021 /* used to set WCS */ + +#define SZ_IMCURVAL 160 +#define PACKED 0040000 +#define COMMAND 0100000 +#define IIS_READ 0100000 +#define IMC_SAMPLE 0040000 +#define IMT_FBCONFIG 077 + +struct iism70 { + short tid; + short thingct; + short subunit; + short checksum; + short x, y, z; + short t; +}; + +#ifndef abs +#define abs(a) (((a)<0)?(-a):(a)) +#endif + +#ifndef min +#define min(a,b) ((a)<(b)?(a):(b)) +#endif +#ifndef max +#define max(a,b) ((a)<(b)?(b):(a)) +#endif + +static int interactive=0; +static int background=0; +static int datain, dataout=0; +static char framebuf[512*512]; +static int frame=1, reference_frame=1, display_frame=1; +static int fb_config_index=1, fb_nframes=1; +static int Fb_width = 512, Fb_height = 512; +static char wcsbuf[MAX_FRAMES][SZ_WCSBUF]; + + +/* FIFO -- Text fifo i/o. + */ +main (argc, argv) +int argc; +char **argv; +{ + fd_set fds; + + if (argc > 1) + if (strcmp (argv[1], "-i") == 0) + interactive++; /* type in cursor values */ + + /* Open the output fifo. We have to open it ourselves first as a + * client to get around the fifo open-no-client error. + */ + if ((datain = open (O_DEVNAME, O_RDONLY|O_NDELAY)) != -1) { + if ((dataout = open (O_DEVNAME, O_WRONLY|O_NDELAY)) != -1) + fcntl (dataout, F_SETFL, O_WRONLY); + close (datain); + } + + /* Open the input stream, a FIFO pseudodevice file used by + * applications to send us commands and data. + */ + if ((datain = open (I_DEVNAME, O_RDONLY|O_NDELAY)) == -1) { + if ((datain = open (OLD_DEVNAME, O_RDONLY|O_NDELAY)) == -1) + fprintf (stderr, "Warning: cannot open %s\n", I_DEVNAME); + } else { + /* Clear O_NDELAY for reading. */ + fcntl (datain, F_SETFL, O_RDONLY); + } + + FD_ZERO (&fds); FD_SET (datain, &fds); + while (select (FD_SETSIZE, &fds, NULL, NULL, NULL) > 0) { + ev_cmdinput(); + fflush (stdout); + fflush (stderr); + FD_ZERO (&fds); FD_SET (datain, &fds); + } + + close (datain); + exit (0); +} + + +/* EV_CMDINPUT -- Called when command or data input has arrived via the + * pseudodevice input stream from some applications process. + */ +ev_cmdinput() +{ + register unsigned char *cp; + register int sum, i; + register short *p; + int ndatabytes, nbytes, n, ntrys=0; + static int errmsg=0, bswap=0; + struct iism70 iis; + char buf[SZ_FIFOBUF]; + int fb_index; + + /* Get the IIS header. */ + if (read (datain, (char *)&iis, sizeof(iis)) < sizeof(iis)) { + fprintf (stderr, "imtool: command input read error\n"); + fflush (stderr); + return (0); + } else if (bswap) + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + + /* Verify the checksum. If it fails swap the bytes and try again. + */ + for (;;) { + for (i=0, sum=0, p=(short *)&iis; i < 8; i++) + sum += *p++; + if ((sum & 0177777) == 0177777) + break; + + if (ntrys++) { + if (!errmsg++) { + fprintf (stderr, "imtool: bad data header checksum\n"); + fflush (stderr); + if (bswap) + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + fprintf (stderr, "noswap:"); + for (i=0, p=(short *)&iis; i < 8; i++) + fprintf (stderr, " %6o", p[i]); + fprintf (stderr, "\n"); + + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + fprintf (stderr, " swap:"); + for (i=0, p=(short *)&iis; i < 8; i++) + fprintf (stderr, " %6o", p[i]); + fprintf (stderr, "\n"); + fflush (stderr); + } + break; + + } else { + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + bswap = !bswap; + } + } + + ndatabytes = -iis.thingct; + if (!(iis.tid & PACKED)) + ndatabytes *= 2; + + /* Log command. */ + fprintf (stderr, + "subunit=%06o tid=%06o nbytes=%7d x=%06o y=%06o z=%06o\n", + iis.subunit & 077, + iis.tid, + ndatabytes, + iis.x & 0177777, + iis.y & 0177777, + iis.z & 0177777); + fflush (stderr); + + switch (iis.subunit & 077) { + case FEEDBACK: + /* The feedback unit is used only to clear a frame. + */ + set_reference_frame (decode_frameno (iis.z & 07777)); + /* erase (rf_p); */ + fprintf (stderr, "erase frame %d\n", reference_frame); + break; + + case LUT: + /* Data mode writes to the frame lookup tables are not implemented. + * A command mode write to the LUT subunit is used to connect + * image memories up to the RGB channels, i.e., to select the frame + * to be displayed. We ignore any attempt to assign multiple + * frames to multiple color channels, and just do a simple frame + * select. + */ + if (iis.subunit & COMMAND) { + int frame, z, n; + short x[14]; + + if (read (datain, (char *)x, ndatabytes) == ndatabytes) { + if (bswap) + bswap2 ((char *)x, (char *)x, ndatabytes); + + z = x[0]; + if (!z) z = 1; + for (n=0; !(z & 1); z >>= 1) + n++; + + frame = max (1, n + 1); + if (frame > fb_nframes) { + if (frame < MAX_FRAMES) { + /* set_fbconfig (fb_config_index, frame); */ + fprintf (stderr, "set_fbconfig (%d, %d)\n", + fb_config_index, frame); + } else { + fprintf (stderr, "imtool warning: "); + fprintf (stderr, + "attempt to display nonexistent frame %d\n", frame); + frame = fb_nframes - 1; + } + } + + /* set_frame (frame); */ + fprintf (stderr, "set_frame (%d)\n", frame); + return (0); + } + } + + case MEMORY: + /* Load data into the frame buffer. Data is assumed to be byte + * packed. + */ + if (iis.tid & IIS_READ) { + /* Read from the display. + */ + unsigned char *fb, *ip; + int nbytes, nleft, n, x, y; + long starttime; + + /* Get the frame to be read from. */ + set_reference_frame (decode_frameno (iis.z & 07777)); + + fb = (unsigned char *)framebuf; + nbytes = ndatabytes; + x = iis.x & 01777; + y = iis.y & 01777; + + ip = max (fb, min (fb + Fb_width * Fb_height - nbytes, + fb + y * Fb_width + x)); + if (ip != fb + y * Fb_width + x) { + fprintf (stderr, + "imtool: attempted read out of bounds on framebuf\n"); + fprintf (stderr, + "read %d bytes at [%d,%d]\n", nbytes, x, y); + } + + /* Log i/o command. */ + fprintf (stderr, "read %d bytes at x=%d, y=%d\n", + nbytes, x, y); + + /* Return the data from the frame buffer. */ + starttime = time(0); + for (nleft = nbytes; nleft > 0; nleft -= n) { + n = (nleft < SZ_FIFOBUF) ? nleft : SZ_FIFOBUF; + if ((n = write (dataout, ip, n)) <= 0) { + if (n < 0 || (time(0) - starttime > IO_TIMEOUT)) { + fprintf (stderr, "IMTOOL: timeout on write\n"); + break; + } + } else + ip += n; + } + + return (0); + + } else { + /* Write to the display. + */ + unsigned char *fb, *op; + int nbytes, nleft, n, x, y; + long starttime; + + /* Get the frame to be written into (encoded with a bit for + * each frame, 01 is frame 1, 02 is frame 2, 04 is frame 3, + * and so on). + */ + set_reference_frame (decode_frameno (iis.z & 07777)); + + /* Get a pointer into the frame buffer where the data will + * be put. + */ + fb = (unsigned char *)framebuf; + nbytes = ndatabytes; + x = iis.x & 07777; + y = iis.y & 07777; + + op = max (fb, min (fb + Fb_width * Fb_height - nbytes, + fb + y * Fb_width + x)); + if (op != fb + y * Fb_width + x) { + fprintf (stderr, + "imtool: attempted write out of bounds on framebuf\n"); + fprintf (stderr, + "write %d bytes to [%d,%d]\n", nbytes, x, y); + } + + /* Log i/o command. */ + fprintf (stderr, "write %d bytes at x=%d, y=%d\n", + nbytes, x, y); + + /* Read the data into the frame buffer. + */ + starttime = time(0); + for (nleft = nbytes; nleft > 0; nleft -= n) { + n = (nleft < SZ_FIFOBUF) ? nleft : SZ_FIFOBUF; + if ((n = read (datain, op, n)) <= 0) { + if (n < 0 || (time(0) - starttime > IO_TIMEOUT)) + break; + } else { + /* Set any zeroed pixels to the background color, + * if a special background color is specified. + */ + if (background) + for (cp=op, i=n; --i >= 0; cp++) + if (!*cp) + *cp = background; + op += n; + } + } + + /* Refresh the display, if the current display frame is the + * same as the reference frame. + if (rf_p == df_p) { + BRect fb_r, pw_r; + + fb_r.r_left = x * zoom; + fb_r.r_top = y * zoom; + fb_r.r_width = min (nbytes * zoom, fb_width); + fb_r.r_height = ((nbytes*zoom*zoom + fb_width-1)/fb_width); + + Bpw_get_region_rect (gio_pw, &pw_rect); + Bpw_lock (gio_pw, &pw_rect); + + pw_rect.r_left = df_p->fb_xoff; + pw_rect.r_top = df_p->fb_yoff; + + if (maprect (&fb_rect, &fb_r, &pw_rect, &pw_r)) + if (maprect (&pw_rect, &pw_r, &fb_rect, &fb_r)) { + ds_write (gio_pw, + pw_r.r_left, pw_r.r_top, + pw_r.r_width, pw_r.r_height, + PIX_SRC | PIX_COLOR(NGREY-1), + df_p->fb_pr, fb_r.r_left, fb_r.r_top); + + if (pw_r.r_top + pw_r.r_height >= pw_rect.r_height + - cb_height) + put_colorbar(); + } + + Bpw_unlock (gio_pw); + } + */ + + return (0); + } + break; + + case WCS: + /* Read or write the WCS for a frame. The frame number to + * which the WCS applies is passed in Z and the frame buffer + * configuration in T. The client changes the frame buffer + * configuration in a WCS set. The WCS text follows the header + * as byte packed ASCII data. + */ + if (iis.tid & IIS_READ) { + /* Return the WCS for the referenced frame. + */ + register char *op; + register int n; + char emsg[SZ_WCSBUF]; + char *text; + int frame; + + for (op=emsg, n=SZ_WCSBUF; --n >=0; ) + *op++ = 0; + + frame = decode_frameno (iis.z & 07777); + if (frame > fb_nframes) + strcpy (text=emsg, "[NOSUCHFRAME]\n"); + else { + set_reference_frame (frame); + text = wcsbuf[reference_frame-1]; + } + + fprintf (stderr, "query wcs:\n"); + write (2, text, SZ_WCSBUF); + + write (dataout, text, SZ_WCSBUF); + + } else { + /* Set the WCS for the referenced frame. + */ + char buf[1024]; + int fb_config, frame; + + frame = decode_frameno (iis.z & 07777); + if (frame > fb_nframes) + if (frame < MAX_FRAMES) { + /* set_fbconfig (fb_config_index, frame); */ + fprintf (stderr, "set_fbconfig (%d, %d)\n", + fb_config_index, frame); + } + + set_reference_frame (frame); + if ((fb_config = iis.t & 077) != fb_config_index) { + /* set_fbconfig (fb_config_index, frame); */ + fprintf (stderr, "set_fbconfig (%d, %d)\n", + fb_config_index, frame); + } + + /* Read in and set up the WCS. */ + if (read (datain, buf, ndatabytes) == ndatabytes) + strncpy (wcsbuf[reference_frame-1], buf, SZ_WCSBUF); + + fprintf (stderr, "set wcs:\n"); + write (2, buf, SZ_WCSBUF); + + /* + strcpy (rf_p->fb_ctran.format, W_DEFFORMAT); + rf_p->fb_ctran.imtitle[0] = '\0'; + rf_p->fb_ctran.valid = 0; + rf_p->fb_imageno++; + rf_p->fb_objno = 1; + + wcs_update (rf_p); + if (rf_p == df_p) + window_set (gio_frame, FRAME_LABEL, framelabel(), 0); + */ + } + + return (0); + break; + + case IMCURSOR: + /* Read or write the logical image cursor. This is an extension + * added to provide a high level cursor read facility; this is + * not the same as a low level access to the IIS cursor subunit. + * Cursor reads may be either nonblocking (immediate) or blocking, + * using the keyboard or mouse to terminate the read, and + * coordinates may be returned in either image (world) or frame + * buffer pixel coordinates. + */ + if (iis.tid & IIS_READ) { + /* Read the logical image cursor. In the case of a blocking + * read all we do is initiate a cursor read; completion occurs + * when the user hits a key or button. + */ + fprintf (stderr, "read cursor position\n"); + if (iis.tid & IMC_SAMPLE) { + /* Sample the cursor position. */ + /* + register struct ctran *ct; + int wcs = iis.z; + int sx, sy; + float wx, wy; + + wx = sx = last_x + pw_rect.r_left; + wy = sy = last_y + pw_rect.r_top; + + if (wcs) { + ct = wcs_update (df_p); + if (ct->valid) { + if (abs(ct->a) > .001) + wx = ct->a * sx + ct->c * sy + ct->tx; + if (abs(ct->d) > .001) + wy = ct->b * sx + ct->d * sy + ct->ty; + } + } + */ + + int wcs = iis.z, key = 'q'; + float wx=1.0, wy=1.0; + + /* Return the cursor value on the output datastream encoded + * in a fixed size ascii buffer. + */ + gio_retcursorval (wx, wy, display_frame*100+wcs, key, ""); + + } else { + /* Initiate a user triggered cursor read. */ + /* gio_readcursor (iis.z); */ + int wcs = iis.z, key = 'q'; + float wx=1.0, wy=1.0; + gio_retcursorval (wx, wy, display_frame*100+wcs, key, ""); + } + + } else { + /* Write (set) the logical image cursor position. */ + /* + fprintf (stderr, "write cursor position\n"); + register struct ctran *ct; + int sx = iis.x, sy = iis.y; + float wx = sx, wy = sy; + int wcs = iis.z; + + if (wcs) { + ct = wcs_update (df_p); + if (ct->valid) { + if (abs(ct->a) > .001) + sx = (wx - ct->tx) / ct->a; + if (abs(ct->d) > .001) + sy = (wy - ct->ty) / ct->d; + } + } + + gio_setcursorpos (sx - pw_rect.r_left, sy - pw_rect.r_top); + */ + } + + return (0); + break; + + default: + /* Ignore unsupported command input. + */ + break; + } + + /* Discard any data following the header. */ + if (!(iis.tid & IIS_READ)) + for (nbytes = ndatabytes; nbytes > 0; nbytes -= n) { + n = (nbytes < SZ_FIFOBUF) ? nbytes : SZ_FIFOBUF; + if ((n = read (datain, buf, n)) <= 0) + break; + } + + fflush (stderr); + return (0); +} + + +/* SET_REFERENCE_FRAME -- Set reference frame. If the frame referenced is + * greater than the current number of frames, attempt to increase the number + * of frames. + */ +static +set_reference_frame (n) +register int n; +{ + reference_frame = max (1, n); + if (reference_frame > fb_nframes) { + if (reference_frame < MAX_FRAMES) { + /* set_fbconfig (fb_config_index, reference_frame); */ + fprintf (stderr, "set_fbconfig %d %d\n", + fb_config_index, reference_frame); + } else { + fprintf (stderr, "imtool warning: "); + fprintf (stderr, + "attempt to reference nonexistent frame %d\n", + reference_frame); + reference_frame = fb_nframes; + } + } + + /* rf_p = frames + (reference_frame - 1); */ +} + + +/* DECODE_FRAMENO -- Decode encoded IIS register frame number. + */ +static +decode_frameno (z) +register int z; +{ + register int n; + + /* Get the frame number, encoded with a bit for each frame, 01 is + * frame 1, 02 is frame 2, 04 is frame 3, and so on. + */ + if (!z) z = 1; + for (n=0; !(z & 1); z >>= 1) + n++; + + return (max (1, n + 1)); +} + + +/* BSWAP2 - Move bytes from array "a" to array "b", swapping successive + * pairs of bytes. The two arrays may be the same but may not be offset + * and overlapping. + */ +static +bswap2 (a, b, nbytes) +char *a, *b; /* input array */ +int nbytes; /* number of bytes to swap */ +{ + register char *ip=a, *op=b, *otop; + register unsigned temp; + + /* Swap successive pairs of bytes. + */ + for (otop = op + (nbytes & ~1); op < otop; ) { + temp = *ip++; + *op++ = *ip++; + *op++ = temp; + } + + /* If there is an odd byte left, move it to the output array. + */ + if (nbytes & 1) + *op = *ip; +} + + +/* GIO_RETCURSORVAL -- Return the cursor value on the output datastream to + * the client which requested the cursor read. + */ +static +gio_retcursorval (wx, wy, wcs, key, strval) +float wx, wy; /* cursor coordinates */ +int wcs; /* encoded WCS value */ +int key; /* keystroke used as trigger */ +char *strval; /* optional string value */ +{ + register char *op; + register int n; + char curval[SZ_IMCURVAL]; + char keystr[20]; + + for (op=curval, n=SZ_IMCURVAL; --n >=0; ) + *op++ = 0; + + /* If running FIFO in interactive mode, allow the user to type + * in the cursor value on the standard input. + */ + if (interactive) { + fprintf (stderr, "enter cursor value string: "); + fflush (stderr); + if (fgets (curval, SZ_IMCURVAL, stdin) != NULL) + goto ret; + } + + /* Encode the cursor value. */ + if (key == EOF) + sprintf (curval, "EOF\n"); + else { + if (isprint (key) && !isspace(key)) { + keystr[0] = key; + keystr[1] = '\0'; + } else + sprintf (keystr, "\\%03o", key); + + sprintf (curval, "%10.3f %10.3f %d %s %s\n", + wx, wy, wcs, keystr, strval); + } +ret: + fprintf (stderr, "%s", curval); + + /* Send it to the client program. */ + write (dataout, curval, sizeof(curval)); +} + + +#define mask(s) (1<<((s)-1)) +#define setvec(vec, a) \ + vec.sv_handler = a; vec.sv_mask = vec.sv_onstack = 0 + +static int ringring; + + +/* WMSEC -- Suspend task execution (sleep) for the specified number + * of milliseconds. + */ +wmsec (msec) +int msec; +{ + struct itimerval itv, oitv; + register struct itimerval *itp = &itv; + struct sigvec vec, ovec; +#ifdef SUNOS4 + void napmsx(); +#else + int napmsx(); +#endif + int omask; + + if (msec == 0) + return; + + timerclear (&itp->it_interval); + timerclear (&itp->it_value); + if (setitimer (ITIMER_REAL, itp, &oitv) < 0) + return; + + setvec (ovec, SIG_DFL); + omask = sigblock(0); + + itp->it_value.tv_usec = (msec * 1000) % 1000000; + itp->it_value.tv_sec = (msec * 1000) / 1000000; + + if (timerisset (&oitv.it_value)) { + if (timercmp(&oitv.it_value, &itp->it_value, >)) + oitv.it_value.tv_sec -= itp->it_value.tv_sec; + else { + itp->it_value = oitv.it_value; + /* This is a hack, but we must have time to + * return from the setitimer after the alarm + * or else it'll be restarted. And, anyway, + * sleep never did anything more than this before. + */ + oitv.it_value.tv_sec = 1; + oitv.it_value.tv_usec = 0; + } + } + + setvec (vec, napmsx); + (void) sigvec (SIGALRM, &vec, &ovec); + ringring = 0; + (void) setitimer (ITIMER_REAL, itp, (struct itimerval *)0); + + while (!ringring) + sigpause (omask &~ mask(SIGALRM)); + + (void) sigvec (SIGALRM, &ovec, (struct sigvec *)0); + (void) setitimer (ITIMER_REAL, &oitv, (struct itimerval *)0); +} + + +#ifdef SUNOS4 +static void +#else +static int +#endif +napmsx() +{ + ringring = 1; +} diff --git a/unix/sun/gterm.c b/unix/sun/gterm.c new file mode 100644 index 00000000..57c4eb43 --- /dev/null +++ b/unix/sun/gterm.c @@ -0,0 +1,1984 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <suntool/sunview.h> +#include <suntool/canvas.h> +#include <suntool/panel.h> +#include <suntool/tty.h> +#include <suntool/walkmenu.h> +#include <suntool/tool_struct.h> +#include <sunwindow/win_cursor.h> +#include <sgtty.h> +#include <stdio.h> +#include <ctype.h> +#include "gterm.h" + +/* + * GTERM -- Graphics terminal emulator. This code implements a virtual + * graphics terminal consisting of independent text and graphics frames. + * The text (tty) frame is a standard Sun TTY frame. The graphics (gio) + * frame is a tektronix 4012 with extensions, some of which are patterned + * after the Retrographics vt100, Pericom, etc., and others of which are or + * will be added to provide GKS like capabilities via a conventional data + * driven graphics terminal interface. The tty and gio frames are independent + * frames under Sunview, hence they may be resized, moved, opened or closed, + * hidden or exposed, etc., independently of each other. Both frames are + * active at all times, but since a single terminal i/o stream is used to + * drive both frames an applications program can communicate with only one + * frame at a time, just like a conventional graphics terminal. + * + * D.Tody, January 1987 (NOAO/IRAF project) + */ + +#define MAX_ARGS 50 /* max tty or gio cmdline args */ +#define DEF_TEKXRES 1024 /* default logical X resolution */ +#define DEF_TEKYRES 780 /* default logical Y resolution */ + +#define NO_ACTION 0 /* no action on open/close ws */ +#define SHOW_FRAME 1 /* show or unshow gio frame */ +#define UNSHOW_FRAME 1 /* show or unshow gio frame */ +#define EXPOSE_FRAME 2 /* expose or hide gio frame */ +#define HIDE_FRAME 2 /* expose or hide gio frame */ +#define CROSSHAIR_OFF 1 /* crosshair cursor off */ +#define CROSSHAIR_ON 2 /* turn crosshair cursor on */ +#define SZ_LOGBUF 1024 /* size of logfile buffer */ +#define SZ_GINMODETERM 10 /* ginmode string length */ +#define SZ_FNAME 128 + +#define R_TYPE 0 /* 0=postscript, 1=rasterfile */ +#define R_DISPOSE "lpr -s %s" /* dispose command */ +#define R_FILENAME "" /* output filename */ + +/* External variables. */ +extern int gio_graphicsenabled; /* set when in graphics mdoe */ +int cursor_show = -1; /* cursor state: on or off */ +Window gt_baseframe, gt_ttysw, gio_frame, gio_canvas; +FILE *gt_logfp = NULL; /* logfile file pointer */ + +/* Screendump stuff. */ +int r_type = R_TYPE; +char r_dispose[SZ_FNAME+1] = R_DISPOSE; +char r_filename[SZ_FNAME+1] = R_FILENAME; + +/* Both external and a user option. */ +int clip_graphics = 1; /* disable rasterop clipping */ + +/* User options. */ +static int graphics_enable; /* enable graphics plane */ +static int openws_action; /* default action on openws */ +static int closews_action; /* default action on closews */ +static int closews_pause; /* pause/confirm closews? */ +static int canvas_retained; /* retain the canvas pixwin? */ +static int reverse_video; /* normal or reverse video */ +static int color; /* color or monochrome graphics */ +static int win_xsize; /* standard size graphics frame */ +static int win_ysize; +static int win_xoff; /* standard offset from tty fr. */ +static int win_yoff; +static int ignore; /* ignore suspend/stop codes? */ +static char gin_modeterm[SZ_GINMODETERM+1]; +static char logfile[SZ_FNAME+1] = "gterm.out"; + +/* The following are used to save and later restore the option parameters. */ +static int s_clip_graphics = 1; +static int s_graphics_enable = GRAPHICS_ON; +static int s_openws_action = SHOW_FRAME; +static int s_closews_action= HIDE_FRAME; +static int s_closews_pause = 0; +static int s_canvas_retained = 1; +static int s_reverse_video = 0; +static int s_color = 1; +static int s_win_xsize = 800; +static int s_win_ysize = 630; +static int s_win_xoff = 100; +static int s_win_yoff = 19; +static int s_ignore = 0; +static char s_gin_modeterm[SZ_GINMODETERM] = "015"; + +/* Internal state variables. */ +static int cursor_type = -1; /* crosshair or small cursor */ +static int cursor_read_pending=0; /* waiting for cursor event */ +static int key_left = 0; /* key aliased to left msbutton */ +static int key_middle = 0; /* key aliased to mid msbutton */ +static int key_right = 0; /* key aliased to mid msbutton */ +static int last_key = 0; /* last cursor read key */ +static int last_x= -1,last_y= -1; /* last cursor read position */ +static int pause_mode = 0; /* waiting for closews event */ +static int cursor_used = 0; /* set if cursor is used */ +static int gio_frame_has_moved=0; /* set when user moves giowin */ +static int setup_xoff = 140; /* offset to setup panel */ +static int setup_yoff = 60; +static int tty_lastx, tty_lasty; /* cursor position in gt_ttysw */ +static int height_is_set = 0; /* tty w. height set on cmdline */ +static int tty_nlines = 0; /* number of lines in tty w. */ +static int shell = 0; /* we are running a shell */ +static char t_suspc, t_dsuspc, t_set=0; + +/* The following is a kludge and should be determined at runtime */ +static int pty_fd = 3; /* fd of tty pseudoterminal */ + +/* Graphics fonts. */ +static char fb_courier[] = "/usr/lib/fonts/fixedwidthfonts/cour.b.%d"; +static char fr_courier[] = "/usr/lib/fonts/fixedwidthfonts/cour.r.%d"; +static char fr_screen[] = "/usr/lib/fonts/fixedwidthfonts/screen.r.%d"; +static char fb_screen[] = "/usr/lib/fonts/fixedwidthfonts/screen.b.%d"; + +#define FULLSCREEN 5 +struct fonttab alpha_fonts[] = { + 10, 7, 12, 560, 420, NULL, fb_courier, "10:[560x420]", + 12, 8, 14, 640, 490, NULL, fb_courier, "12:[640x490]", + 14, 9, 16, 720, 560, NULL, fb_courier, "14:[720x560]", + 16, 10, 18, 800, 630, NULL, fb_courier, "16:[800x630]", + 18, 11, 19, 880, 665, NULL, fb_courier, "18:[880x665]", + 24, 14, 25, 1142, 890, NULL, fb_courier, "24:fullscreen", + /* Note nentries must match panel choice list */ + 0, 0, 0, 0, 0, NULL, NULL, NULL +}; + +struct fonttab text_fonts[] = { + 11, 7, 11, 560, 0, NULL, fr_screen, "screen.r.11", + 12, 8, 14, 640, 0, NULL, fb_screen, "screen.b.12", + 14, 9, 16, 720, 0, NULL, fb_screen, "screen.b.14", + 16, 10, 18, 800, 0, NULL, fb_courier, "courier.b.16", + 18, 11, 19, 880, 0, NULL, fb_courier, "courier.b.18", + 24, 14, 25, 1142, 0, NULL, fb_courier, "courier.b.24", + /* Note nentries must match panel choice list */ + 0, 0, 0, 0, 0, NULL, NULL, NULL +}; + +#define DEF_TEXTFONT 4 +static int alpha_font_index; +static int text_font_index = DEF_TEXTFONT; +static struct fonttab *alpha_font = NULL; +static struct fonttab *text_font = NULL; + +#define SWAP(a,b) {int temp; temp=a;a=b;b=temp;} +#define HEIGHTADJUST \ + (tool_headerheight((int)window_get(gt_baseframe, FRAME_SHOW_LABEL)) + \ + TOOL_BORDERWIDTH) + +static short iconimage[] = { +#include "gterm.icon" +}; +DEFINE_ICON_FROM_IMAGE (icon, iconimage); + +static int main_argc, tty_argc, gio_argc; +static char **main_argv, *tty_argv[MAX_ARGS], *gio_argv[MAX_ARGS]; +static unsigned char red[2] = { 0, 255 }; +static unsigned char green[2] = { 0, 255 }; +static unsigned char blue[2] = { 128, 0 }; + +static Menu_item logitem; +static struct rect screen; +static struct pixwin *pw; +static Panel setup_panel, pause_panel; +static Window setup_frame, pause_frame; +static Notify_value ev_gt_ttysw(); +static Notify_value ev_ttyframe(); +static Notify_value ev_gioframe(); +static Notify_value ev_gioinput(); +static Notify_func sig_tstp(); +static tty_adjustheight(); +extern char *getenv(); + + +/* GTERM_MAIN -- Create the graphics terminal window tree, i.e., the panel + * subwindow and tty subwindow, the gio subframe canvas in which graphics + * will be drawn, and the setup popup which is used to set the terminal + * options. Only the panel and tty (text) window is shown initially; this + * is functionally equivalent to a shelltool window with all the same command + * line arguments. Additional command line arguments are recognized for + * initialization of the graphics frame. + */ +#ifdef STANDALONE +main (argc, argv) +#else +gterm_main (argc, argv) +#endif +int argc; +char **argv; +{ + char *s; + + /* Set user settable options to their initial compiled in values. */ + restore_params(); + + main_argc = argc; + main_argv = argv; + parse_args (argc, argv, &tty_argc, tty_argv, &gio_argc, gio_argv); + + /* Screendump stuff. */ + if (s = getenv ("R_DISPOSE")) + strcpy (r_dispose, s); + if (s = getenv ("R_FILENAME")) + strcpy (r_filename, s); + if (s = getenv ("R_RASTERFILE")) { + strcpy (r_filename, s); + r_type = 1; + } + + /* Create the base frame for all the GTERM windows. */ + gt_baseframe = window_create (NULL, FRAME, + FRAME_ICON, &icon, + FRAME_LABEL, "gterm - NOAO/IRAF Sunview Graphics Terminal V1.2", + FRAME_ARGC_PTR_ARGV, &tty_argc, tty_argv, + FRAME_NO_CONFIRM, FALSE, + 0); + if (gt_baseframe == NULL) + _exit (1); + screen = *(struct rect *) window_get (gt_baseframe, WIN_SCREEN_RECT); + + create_tty_subwindow (tty_argc, tty_argv); + create_gio_popup (gio_argc, gio_argv); + create_frame_menu (gt_baseframe); + + /* Save initial options settings for later reset (in setup panel). */ + save_params(); + + notify_interpose_event_func (gt_baseframe, ev_ttyframe, NOTIFY_SAFE); + notify_interpose_event_func (gt_ttysw, ev_gt_ttysw, NOTIFY_SAFE); + notify_interpose_event_func (gio_frame, ev_gioframe, NOTIFY_SAFE); + notify_interpose_event_func (gio_canvas, ev_gioinput, NOTIFY_SAFE); + + notify_set_signal_func (gt_baseframe, sig_tstp, SIGTSTP, NOTIFY_SYNC); + +#ifdef TTY_TTY_FD + /* SunOS 3.4 provides just what we needed to fix the pty-fd kludge! */ + pty_fd = (int) window_get (ttysw, TTY_TTY_FD); +#endif + gio_setup (pty_fd, pw); + gio_hardreset (DEF_TEKXRES, DEF_TEKYRES, alpha_font, text_font); + + window_main_loop (gt_baseframe); + exit (0); +} + + +/* PARSE_ARGS -- Parse the argument list into the arguments for the tty + * frame and the arguments for the gio frame. This is very easy; the gio + * args, if any, are whatever follows the arg "-G" in the argument list. + * All args preceding the -G are considered to be tty args. + */ +static +parse_args (argc, argv, tty_argc, tty_argv, gio_argc, gio_argv) +int argc; +char *argv[]; +int *tty_argc, *gio_argc; +char *tty_argv[], *gio_argv[]; +{ + register char *argp, *last; + register int arg = 1; + + /* Copy the tty arguments. */ + tty_argv[0] = argv[0]; + for (*tty_argc=1; arg <= argc && (argp = argv[arg]) != NULL; arg++) + if (strcmp (argv[arg], "-G") != 0) { + tty_argv[(*tty_argc)++] = argp; + if ((strcmp(argp, "-Ws") == 0) || (strcmp(argp, "-size") == 0)) + height_is_set = 1; + else if ((strcmp(argp, "-Wh") == 0) || + (strcmp(argp, "-height") == 0)) { + height_is_set = 0; + tty_nlines = atoi (argv[arg+1]); + } + } else { + arg++; + break; + } + + gio_argv[0] = argv[0]; + last = ""; + + /* Copy the gio arguments. */ + for (*gio_argc=1; arg <= argc && (argp = argv[arg]) != NULL; arg++) { + + /* If an argument string is encountered which is not an argument + * to a GIO window switch, assume that it is the first word of the + * command to be executed in the text window, and move the + * remaining arguments to the tty_argv list. + */ + if (strncmp(last,"-Gopen",3) && strncmp(last,"-Gclose",3) && + isalpha(argp[0])) { + + for (; arg <= argc && (argp = argv[arg]) != NULL; arg++) + tty_argv[(*tty_argc)++] = argp; + break; + } + + gio_argv[(*gio_argc)++] = argp; + last = argp; + } + + tty_argv[(*tty_argc)] = NULL; + gio_argv[(*gio_argc)] = NULL; +} + + +/* CREATE_TTY_SUBWINDOW -- Create a standard TTY subwindow of the base frame. + * This code emulates the shelltool arguments. + */ +static +create_tty_subwindow (argc, argv) +int argc; +char *argv[]; +{ + static char *sh_argv[2]; + register char *argp; + register int arg; + char **tty_argv = argv; + char *tool_name = argv[0]; + char *init_cmd = NULL; + char *bold_name = NULL; + int become_console = 0; + + /* Get gt_ttysw related args. The standard frame arguments will + * already have been removed from the list when the base frame was + * created, leaving only the tty specific arguments and possibly the + * command to be run. + */ + sh_argv[0] = NULL; + sh_argv[1] = NULL; + + for (arg=1; arg < argc && (argp = argv[arg]); arg++) { + if (*argp != '-') + break; + else if (!strncmp (argp, "-ignore", 3)) { + ignore++; + continue; + } + + switch (*(argp+1)) { + case 'C': + become_console = 1; + break; + case '?': + tool_usage (tool_name); + print_usage (tool_name); + window_destroy (gt_baseframe); + exit (1); + case 'B': + if (argc > 1) + bold_name = argv[++arg]; + break; + case 'I': + if (argc > 1) + init_cmd = argv[++arg]; + break; + case 'T': + gio_enable (0); + break; + } + } + + /* Get path to command interpreter to be run. */ + if (argp == NULL || arg >= argc) { + shell++; + tty_argv = sh_argv; + if ((tty_argv[0] = getenv("SHELL")) == NULL) { + tty_argv[0] = "/bin/sh"; + if (ignore) + shell = 0; + } + } else { + tty_argv = &argv[arg]; + if (!strcmp(tty_argv,"csh") || !strcmp(tty_argv,"/bin/csh")) + shell++; + else if (!ignore) + shell++; + } + + gt_ttysw = window_create (gt_baseframe, TTY, + TTY_ARGV, tty_argv, + TTY_QUIT_ON_CHILD_DEATH, TRUE, + TTY_CONSOLE, become_console, + 0); + + window_set (gt_ttysw, + WIN_CONSUME_KBD_EVENTS, KEY_TOP(7), KEY_TOP(8), KEY_TOP(9), 0, + 0); + + if (bold_name) + window_set (gt_ttysw, TTY_BOLDSTYLE_NAME, bold_name, 0); + + /* Pass user supplied command, if given, to the shell. */ + if (init_cmd) { + int len = strlen (init_cmd); + + if (init_cmd[len-1] != '\n') { + init_cmd[len] = '\n'; + len++; + } + ttysw_input (gt_ttysw, init_cmd, len); + } + + window_fit_height (gt_ttysw); + window_fit_height (gt_baseframe); + + /* Only correct the height if the user did not give a pixel value + * for the height. + */ + if (!height_is_set) + tty_adjustheight (tty_nlines); +} + + +/* CREATE_GIO_POPUP -- Create a canvas popup to be used for graphics i/o. + * We use a separate subframe for this so that it may be moved and sized + * independently of the tty window; tty windows like to high and narrow + * (lots of lines) whereas graphs tend to be short and wide (good resolution + * in X). We also like a large graph window to get good resolution, but + * a separate window is desired so that the screen space can be freed up + * when we are not actually doing graphics, and so that the last graph can + * easily be recalled at any time. The standard graphics window should have + * a landscape aspect ratio (y/x=.77), like most terminals and laser printers. + */ +static +create_gio_popup (argc, argv) +int argc; +char **argv; +{ + static unsigned char mono[2]; + register char *argp; + register int arg; + char *frame_argv[64]; + int frame_argc; + char pathname[256]; + char mapname[64]; + int name; + + frame_argv[0] = argv[0]; + frame_argc = 1; + + /* Override the builtin defaults with the values given by the user + * on the command line, if any. + */ + for (arg=1; arg <= argc && (argp = argv[arg]) != NULL; arg++) { + /* Standard Sunview frame args. */ + if (!strcmp (argp, "-Wb") || !strncmp (argp, "-back", 5)) { + red[0] = atoi (argv[++arg]); + green[0] = atoi (argv[++arg]); + blue[0] = atoi (argv[++arg]); + } else if (!strcmp (argp, "-Wf") || !strncmp (argp, "-fore", 5)) { + red[1] = atoi (argv[++arg]); + green[1] = atoi (argv[++arg]); + blue[1] = atoi (argv[++arg]); + } else if (!strcmp (argp, "-Wp") || !strncmp (argp, "-pos", 4)) { + win_xoff = atoi (argv[++arg]) - + (int) window_get (gt_baseframe, WIN_X); + win_yoff = atoi (argv[++arg]) - + (int) window_get (gt_baseframe, WIN_Y); + } else if (!strcmp (argp, "-Ws") || !strncmp (argp, "-size", 5)) { + win_xsize = atoi (argv[++arg]) - (TOOL_BORDERWIDTH * 2); + win_ysize = atoi (argv[++arg]) - (TOOL_BORDERWIDTH * 2); + + /* Graphics options. */ + } else if (!strncmp (argp, "-Gopen", 3)) { + argp = argv[++arg]; + if (!strncmp (argp, "noaction", 1)) + openws_action = NO_ACTION; + else if (!strncmp (argp, "show", 1)) + openws_action = SHOW_FRAME; + else if (!strncmp (argp, "expose", 1)) + openws_action = EXPOSE_FRAME; + else { + fprintf (stderr, + "Warning: unknown argument `%s' to -Gopen\n", argp); + } + } else if (!strncmp (argp, "-Gclose", 3)) { + argp = argv[++arg]; + if (!strncmp (argp, "noaction", 1)) + closews_action = NO_ACTION; + else if (!strncmp (argp, "blank", 1)) + closews_action = UNSHOW_FRAME; + else if (!strncmp (argp, "hide", 1)) + closews_action = HIDE_FRAME; + else { + fprintf (stderr, + "Warning: unknown argument `%s' to -Gclose\n", argp); + } + } else if (!strncmp (argp, "-pause", 2)) { + closews_pause = 1; + } else if (!strncmp (argp, "-nopause", 4)) { + closews_pause = 0; + } else if (!strncmp (argp, "-retain", 4)) { + canvas_retained = 1; + } else if (!strncmp (argp, "-noretain", 6)) { + canvas_retained = 0; + } else if (!strncmp (argp, "-clip", 3)) { + clip_graphics = 1; + } else if (!strncmp (argp, "-noclip", 4)) { + clip_graphics = 0; + } else if (!strncmp (argp, "-color", 3)) { + color = 1; + } else if (!strncmp (argp, "-mono", 2)) { + color = 0; + } else if (!strncmp (argp, "-reverse", 4)) { + SWAP (red[0], red[1]); + SWAP (green[0], green[1]); + SWAP (blue[0], blue[1]); + reverse_video = 1; + } else if (!strncmp (argp, "-noreverse", 6)) { + reverse_video = 0; + } else if (!strncmp (argp, "-ginterm", 2)) { + if (argv[arg+1] && isdigit (argv[arg+1][0])) + strcpy (gin_modeterm, argv[++arg]); + if (argv[arg+1] && isdigit (argv[arg+1][0])) { + strcat (gin_modeterm, " "); + strcat (gin_modeterm, argv[++arg]); + } + gio_setginmodeterm (gin_modeterm); + } else if (!strncmp (argp, "-logfile", 2)) { + strcpy (logfile, argv[++arg]); + } else + frame_argv[frame_argc++] = argp; + } + + /* Open the tek-alpha and text mode graphics fonts. */ + if (gio_getbestfont (win_xsize, win_ysize) == -1) + exit (1); + + /* Open graphics window and canvas. Generate a default size + * landscape mode window and position it relative to the base frame. + */ + gio_frame = window_create (gt_baseframe, FRAME, + FRAME_ARGS, frame_argc, frame_argv, + FRAME_NO_CONFIRM, TRUE, + WIN_HEIGHT, win_ysize + (TOOL_BORDERWIDTH * 2), + WIN_WIDTH, win_xsize + (TOOL_BORDERWIDTH * 2), + WIN_X, win_xoff, + WIN_Y, win_yoff, + 0); + gio_canvas = window_create (gio_frame, CANVAS, + CANVAS_RETAINED, canvas_retained ? TRUE : FALSE, + 0); + + /* Set the initial "plus" type graphics cursor. This changes to + * a full crosshair cursor only when the cursor position is being + * read by the applications program. + */ + gio_setcursor (CURSOR_ON, CROSSHAIR_OFF); + + /* Set input event flags. */ + window_set (gio_canvas, + WIN_CONSUME_PICK_EVENTS, WIN_NO_EVENTS, + WIN_MOUSE_BUTTONS, LOC_DRAG, WIN_UP_EVENTS, 0, + WIN_CONSUME_KBD_EVENTS, WIN_NO_EVENTS, WIN_ASCII_EVENTS, + WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS, 0, + 0); + + /* Get canvas pixwin */ + pw = canvas_pixwin (gio_canvas); + if (pw->pw_pixrect->pr_depth == 1) + color = 0; + + /* Set up the default color map. */ + sprintf (mapname, "MONO%04d", getpid() % 10000); + pw_setcmsname (pw, mapname); + pw_putcolormap (pw, 0, 2, red, green, blue); + + if (!color) { + /* Monochrome graphics. */ + /* window_set (gio_canvas, CANVAS_FAST_MONO, TRUE, 0); */ + if (reverse_video) + pw_whiteonblack (pw, 0, 1); + else + pw_blackonwhite (pw, 0, 1); + } +} + + +static Panel_item pan_graphics_enable, pan_openws_action, pan_closews_action; +static Panel_item pan_closews_pause, pan_retain_graphics, pan_clip_graphics; +static Panel_item pan_graphics_screen, pan_graphics_video, pan_alpha_font; + +/* CREATE_SETUP_POPUP -- Create the popup menu used to set the terminal + * setup options. + */ +static +create_setup_popup() +{ + extern reset_proc(), clear_proc(), gclear_proc(); + extern setup_proc(), toggle_graphics(); + static panel_set_item(), set_ginmodeterm(), set_logfile(); + + setup_frame = window_create (gt_baseframe, FRAME, + FRAME_NO_CONFIRM, TRUE, + WIN_X, setup_xoff, + WIN_Y, setup_yoff, + 0); + setup_panel = window_create (setup_frame, PANEL, 0); + + panel_create_item (setup_panel, PANEL_MESSAGE, + PANEL_ITEM_X, ATTR_COL(11), + PANEL_ITEM_Y, ATTR_ROW(0), + PANEL_LABEL_STRING, "Graphics Terminal Setup Options", + 0); + + pan_graphics_enable = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(1), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Graphics plane: ", + PANEL_CHOICE_STRINGS, "Disable", "Enable", + "Discard Graphics Data", 0, + PANEL_VALUE, graphics_enable, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_openws_action = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(2), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Open workstation action: ", + PANEL_CHOICE_STRINGS, "No action", "Show graphics", + "Expose graphics", 0, + PANEL_VALUE, openws_action, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_closews_action = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(3), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Close workstation action: ", + PANEL_CHOICE_STRINGS, "No action", "Blank graphics", + "Hide graphics", 0, + PANEL_VALUE, closews_action, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_closews_pause = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(4), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Pause on close workstation: ", + PANEL_CHOICE_STRINGS, "No", "Yes", 0, + PANEL_VALUE, closews_pause, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_retain_graphics = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(5), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Retain graphics frame: ", + PANEL_CHOICE_STRINGS, "No", "Yes", 0, + PANEL_VALUE, canvas_retained, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_clip_graphics = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(6), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Clip graphics: ", + PANEL_CHOICE_STRINGS, "No", "Yes", 0, + PANEL_VALUE, clip_graphics, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + if (pw->pw_pixrect->pr_depth > 1) { + pan_graphics_screen = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(7), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Graphics screen type: ", + PANEL_CHOICE_STRINGS, "Mono", "Color", 0, + PANEL_VALUE, color, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + } else { + pan_graphics_screen = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(7), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Graphics screen type: ", + PANEL_CHOICE_STRINGS, "Mono only", 0, + PANEL_VALUE, color, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + } + + pan_graphics_video = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(8), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Graphics video: ", + PANEL_CHOICE_STRINGS, "Normal", "Reverse", 0, + PANEL_VALUE, reverse_video, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_alpha_font = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(9), + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Graphics font and screen sizes:", + PANEL_CHOICE_STRINGS, alpha_fonts[0].label, + alpha_fonts[1].label, + alpha_fonts[2].label, + alpha_fonts[3].label, + alpha_fonts[4].label, + alpha_fonts[5].label, + 0, + PANEL_VALUE, alpha_font_index, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(10) + 3, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Logfile name: ", + PANEL_VALUE, logfile, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, 20, + PANEL_NOTIFY_PROC, set_logfile, + 0); + + panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(11) + 3, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "GIN mode terminators (octal): ", + PANEL_VALUE, gin_modeterm, + PANEL_VALUE_STORED_LENGTH, SZ_GINMODETERM, + PANEL_VALUE_DISPLAY_LENGTH, SZ_GINMODETERM, + PANEL_NOTIFY_PROC, set_ginmodeterm, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(12) + 3, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Reset", 0,0), + PANEL_NOTIFY_PROC, reset_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Clear", 0,0), + PANEL_NOTIFY_PROC, clear_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Gclear", 0,0), + PANEL_NOTIFY_PROC, gclear_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Show graphics", 0,0), + PANEL_NOTIFY_PROC, toggle_graphics, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Quit", 0,0), + PANEL_NOTIFY_PROC, setup_proc, + 0); + + window_fit (setup_panel); + window_fit (setup_frame); +} + + +/* PANEL_SET_ITEM -- Called when an item is seleted in the setup panel to + * set the associated global variable and possibly take some action. + */ +static +panel_set_item (item, value) +Panel_item item; +int value; +{ + if (item == pan_graphics_enable) { + gio_enable (graphics_enable = value); + } else if (item == pan_openws_action) { + openws_action = value; + } else if (item == pan_closews_action) { + closews_action = value; + } else if (item == pan_closews_pause) { + if (closews_pause != value) { + closews_pause = value; + show_pausepanel (0); + } + } else if (item == pan_clip_graphics) { + clip_graphics = value; + } else if (item == pan_graphics_screen) { + if (color != value) { + if (value) + pw_putcolormap (pw, 0, 2, red, green, blue); + else if (reverse_video) + pw_whiteonblack (pw, 0, 1); + else + pw_blackonwhite (pw, 0, 1); + color = value; + } + } else if (item == pan_graphics_video) { + if (reverse_video != value) { + if (pw->pw_pixrect->pr_depth > 1) { + unsigned char r[2], g[2], b[2]; + + pw_getcolormap (pw, 0, 2, r, g, b); + SWAP (r[0], r[1]); + SWAP (g[0], g[1]); + SWAP (b[0], b[1]); + pw_putcolormap (pw, 0, 2, r, g, b); + if (color) + pw_getcolormap (pw, 0, 2, red, green, blue); + } else if (value) { + pw_whiteonblack (pw, 0, 1); + } else + pw_blackonwhite (pw, 0, 1); + + reverse_video = value; + } + } else if (item == pan_retain_graphics) { + if (canvas_retained != value) { + canvas_retained = value; + notify_remove_event_func (gio_canvas, + ev_gioinput, NOTIFY_SAFE); + window_destroy (gio_frame); + parse_args (main_argc, main_argv, + &tty_argc, tty_argv, &gio_argc, gio_argv); + create_gio_popup (gio_argc, gio_argv); + notify_interpose_event_func (gio_canvas, + ev_gioinput, NOTIFY_SAFE); + gio_setup (pty_fd, pw); + gio_reset (DEF_TEKXRES, DEF_TEKYRES, alpha_font, text_font); + } + } else if (item == pan_alpha_font) { + if (alpha_font_index != value) { + struct fonttab *ft = &alpha_fonts[value]; + int xorigin, yorigin, xoffset, yoffset; + int g_xsize, g_ysize, g_xorig, g_yorig; + + /* Determine whether the offset of the subframe from the base + * frame needs to be modified to keep the frame on the screen. + */ + xorigin = (int) window_get (gt_baseframe, WIN_X); + yorigin = (int) window_get (gt_baseframe, WIN_Y); + xoffset = win_xoff; + yoffset = win_yoff; + + g_xsize = ft->win_xsize + (TOOL_BORDERWIDTH * 2); + g_ysize = ft->win_ysize + (TOOL_BORDERWIDTH * 2); + g_xorig = xorigin + xoffset; /* screen relative */ + g_yorig = yorigin + yoffset; /* screen relative */ + + if (g_xorig + g_xsize >= screen.r_width) + xoffset -= (g_xorig + g_xsize - screen.r_width); + if (g_yorig + g_ysize >= screen.r_height) + yoffset -= (g_yorig + g_ysize - screen.r_height); + + /* Resize and/or move the gio frame. The gio_frame event + * handler will detect the resize and select a new font. + */ + window_set (gio_frame, WIN_SHOW, FALSE, + WIN_WIDTH, g_xsize, WIN_HEIGHT, g_ysize, 0); + + /* Cannot set a negative subframe offset, so move base frame + * to screen origin temporarily if the gio frame won't fit at + * the lower right. Note that win_[xy]off are not permanently + * changed, so restoring the original size should return the + * window to its original position. + */ + if (gio_frame_has_moved = (xoffset < 0 || yoffset < 0)) { + window_set (gt_baseframe, WIN_X, 0, WIN_Y, 0, 0); + window_set (gio_frame, + WIN_X, xorigin + xoffset, WIN_Y, yorigin + yoffset, 0); + window_set (gt_baseframe, WIN_X,xorigin, WIN_Y,yorigin, 0); + } else + window_set (gio_frame, WIN_X, xoffset, WIN_Y, yoffset, 0); + + window_set (gio_frame, WIN_SHOW, TRUE, 0); + + /* If the setup panel is on, move it to the top. */ + if ((int) window_get (setup_frame, WIN_SHOW) == TRUE) + window_set (setup_frame, WIN_SHOW, TRUE, 0); + } + } +} + + +/* TOGGLE_FULLSCREEN -- Toggle between a full screen graph and a regular size + * graph. + */ +static +toggle_fullscreen() +{ + static save_index = -1; + + if (alpha_font_index == FULLSCREEN && save_index >= 0) + panel_set_item (pan_alpha_font, save_index); + else { + save_index = alpha_font_index; + panel_set_item (pan_alpha_font, FULLSCREEN); + } +} + + +/* SET_GINMODETERM -- Set the GIN mode terminators. + */ +static Panel_setting +set_ginmodeterm (item, event) +Panel_item item; +Event *event; +{ + strcpy (gin_modeterm, + (char *)panel_get_value (item)); + gio_setginmodeterm (gin_modeterm); + + return (panel_text_notify (item,event)); +} + + +/* SET_LOGFILE -- Set the filename of the logfile. + */ +static Panel_setting +set_logfile (item, event) +Panel_item item; +Event *event; +{ + if (gt_logfp) { + fclose (gt_logfp); + gt_logfp = NULL; + menu_set (logitem, MENU_STRING, "Logging on", 0); + } + + strcpy (logfile, + (char *)panel_get_value (item)); + return (panel_text_notify (item,event)); +} + + +/* SETUP_PROC -- Toggle whether or not the setup panel is shown. + */ +static +setup_proc() +{ + if (setup_frame == NULL) { + create_setup_popup(); + create_setup_popup (0, NULL); + panel_set_item(); + window_set (setup_frame, WIN_SHOW, TRUE, 0); + } else { + window_destroy (setup_frame); + setup_frame = NULL; + } +} + + +/* TEXTCOPY_PROC -- Make a hardcopy of the tty window on the laserwriter. + */ +static +textcopy_proc() +{ + int depth = 1; + + window_set (gt_baseframe, WIN_SHOW, TRUE, 0); + notify_dispatch(); + + screendump ( + (int)window_get(gt_ttysw,WIN_FD), win_get_pixwin(gt_ttysw), + (int) window_get (gt_baseframe, WIN_WIDTH) - TOOL_BORDERWIDTH * 2, + (int) window_get (gt_baseframe, WIN_HEIGHT) - HEIGHTADJUST, + (int) window_get (gt_baseframe, WIN_X) + TOOL_BORDERWIDTH, + (int) window_get (gt_baseframe, WIN_Y) + HEIGHTADJUST - + TOOL_BORDERWIDTH, + depth); +} + + +/* GRAPHCOPY_PROC -- Make a hardcopy of the gio window on the laserwriter. + */ +static +graphcopy_proc() +{ + int depth = 1; + + window_set (gio_frame, WIN_SHOW, TRUE, 0); + notify_dispatch(); + + screendump ( + (int)window_get(gio_canvas,WIN_FD), pw, + (int) window_get (gio_frame, WIN_WIDTH) - TOOL_BORDERWIDTH * 2, + (int) window_get (gio_frame, WIN_HEIGHT) - TOOL_BORDERWIDTH * 2, + (int) window_get (gt_baseframe, WIN_X) + + (int) window_get (gio_frame, WIN_X) + TOOL_BORDERWIDTH, + (int) window_get (gt_baseframe, WIN_Y) + + (int) window_get (gio_frame, WIN_Y) + TOOL_BORDERWIDTH, + depth); +} + + +/* SCREENCOPY_PROC -- Make a bitmap hardcopy of the screen on the laserwriter. + */ +static +screencopy_proc() +{ + int depth = 1; + + screendump ( + (int)window_get(gt_ttysw,WIN_FD), win_get_pixwin(gt_ttysw), + screen.r_width, screen.r_height, screen.r_left, screen.r_top, + depth); +} + + +/* SCREENCOPY8_PROC -- Make a greyscale hardcopy of the screen on the + * laserwriter. + */ +static +screencopy8_proc() +{ + int depth = 8; + + screendump ( + (int)window_get(gt_ttysw,WIN_FD), win_get_pixwin(gt_ttysw), + screen.r_width, screen.r_height, screen.r_left, screen.r_top, + depth); +} + + +/* CREATE_PAUSE_POPUP -- Create the pause popup menu used to wait for + * a user response. + */ +static +create_pause_popup() +{ + pause_frame = window_create (gt_baseframe, FRAME, + FRAME_NO_CONFIRM, TRUE, + WIN_X, win_xoff + 5, + WIN_Y, win_yoff + 5, + 0); + pause_panel = window_create (pause_frame, PANEL, 0); + + panel_create_item (pause_panel, PANEL_MESSAGE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(0), + PANEL_LABEL_STRING, "Hit any key to continue", + 0); + + window_fit (pause_panel); + window_fit (pause_frame); +} + + +/* SHOW_PAUSEPANEL -- Toggle display of the pause panel. + */ +static +show_pausepanel (onoff) +int onoff; +{ + if (onoff == 0) { + if (pause_frame) { + window_destroy (pause_frame); + pause_frame = NULL; + } + } else { + if (!pause_frame) + create_pause_popup(); + window_set (pause_frame, + WIN_X, win_xoff + 5, + WIN_Y, win_yoff + 5, + 0); + window_set (pause_frame, WIN_SHOW, TRUE, 0); + } +} + + +/* CREATE_FRAME_MENU -- Gterm uses a special frame menu which provides the + * standard frame menu as a submenu. + */ +static +create_frame_menu (frame) +Frame frame; +{ + extern textcopy_proc(), graphcopy_proc(), screencopy_proc(); + extern setup_proc(), toggle_graphics(), restart_childpgrp(); + extern toggle_logging(); + Menu new_menu, old_menu; + + /* Get the standard frame menu. */ + old_menu = (Menu) window_get (frame, WIN_MENU); + + /* Create the new frame root menu */ + new_menu = menu_create ( + MENU_PULLRIGHT_ITEM, + "Frame", + old_menu, + MENU_ACTION_ITEM, + "Setup", + setup_proc, + MENU_ACTION_ITEM, + "Continue", + restart_childpgrp, + MENU_ACTION_ITEM, + "Logging on", + toggle_logging, + MENU_ACTION_ITEM, + "Show graph", + toggle_graphics, + MENU_ACTION_ITEM, + "Textcopy", + textcopy_proc, + MENU_ACTION_ITEM, + "Graphcopy", + graphcopy_proc, + MENU_ACTION_ITEM, + "Screencopy", + screencopy_proc, + /* + MENU_ACTION_ITEM, + "Screencopy8", + screencopy8_proc, + */ + 0); + + logitem = menu_find (new_menu, MENU_STRING, "Logging on", 0); + + /* Install the new menu. */ + window_set (frame, WIN_MENU, new_menu, 0); +} + + +/* TOGGLE_LOGGING -- Called from the frame menu to turn logging on/off. + */ +static +toggle_logging() +{ + if (gt_logfp) { + fclose (gt_logfp); + gt_logfp = NULL; + menu_set (logitem, MENU_STRING, "Logging on", 0); + } else { + if ((gt_logfp = fopen (logfile, "a")) == NULL) + fprintf (stderr, "cannot open logfile %s\n", logfile); + else + menu_set (logitem, MENU_STRING, "Logging off", 0); + } +} + + +/* EV_GT_TTYSW -- TTY subwindow input event handler. + */ +static Notify_value +ev_gt_ttysw (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + register int key = event_id(event); + + if (pause_mode && (event_is_ascii(event) || event_is_button(event))) { + /* If we are pausing for input before closing the workstation, + * complete the close workstation operation and discard the event. + */ + show_pausepanel (0); + gio_close_workstation(); + return (NOTIFY_DONE); + } + + if (event_is_ascii(event)) { + /* Save the cursor position in tty window for later restoration. */ + tty_lastx = event_x(event); + tty_lasty = event_y(event); + + /* Ignore control codes if -ignore set? */ + if (iscntrl(key) && key != '\r' && ignore_inputevent(event)) + return (NOTIFY_DONE); + + /* Ignore typein into text window while a cursor read is in + * progress, else an invalid exit from the cursor read may result. + */ + if (cursor_read_pending) + return (NOTIFY_DONE); + + } else if (event_id(event) == KEY_TOP(7) && event_is_down(event)) { + /* Toggle between full screen and regular size graph. */ + toggle_fullscreen(); + + } else if (event_id(event) == KEY_TOP(8) && event_is_down(event)) { + /* Clear or enable the graphics plane. */ + char buf[4]; + + tty_lastx = event_x(event); + tty_lasty = event_y(event); + + /* If already in graphics mode, clear the graphics plane, else + * switch to graphics mode w/o clearing the screen (the user can + * simply type F8 again if they also want to clear the screen). + */ + if (gio_graphicsenabled && !cursor_read_pending) { + buf[0] = '\035'; + buf[1] = '\033'; + buf[2] = '\014'; + ev_ptyoutput (buf, 3); + + } else if (!gio_graphicsenabled && graphics_enable == GRAPHICS_ON) { + buf[0] = '\035'; + buf[1] = '\037'; + ev_ptyoutput (buf, 2); + /* + window_set (gt_ttysw, + WIN_CONSUME_KBD_EVENTS, KEY_TOP(9), 0, + 0); + */ + } + + return (NOTIFY_DONE); + + } else if (event_id(event) == KEY_TOP(9) && event_is_down(event)) { + /* Exit graphics mode, returning to text mode. + */ + if (gio_graphicsenabled && !cursor_read_pending) { + char buf[1]; + + cursor_used++; /* disable pause on CW */ + buf[0] = '\030'; + ev_ptyoutput (buf, 1); + /* + window_set (gt_ttysw, + WIN_IGNORE_KBD_EVENTS, KEY_TOP(9), 0, + 0); + */ + return (NOTIFY_DONE); + } else if (!gio_graphicsenabled) + ttysw_output (gt_ttysw, "\f", 1); + } + + /* Let frame operate upon the event. */ + return (notify_next_event_func (frame, event, arg, type)); +} + + +/* IGNORE_INPUTEVENT -- Ignore the current input event? + * The following is a kludge intended to prevent delivering the suspend + * signal to a process which is run in the gterm window without benefit of + * an intermediate shell. This is only done if "-ignore" (stop signals) + * is specified on the command line, and only if the command being run in + * GTERM is not a shell. This is a dangerous thing to do, as the characters + * may be valid input data to a program operating in raw input mode. + */ +static +ignore_inputevent (event) +Event *event; +{ + register int key = event_id(event); + struct ltchars lt; + struct sgttyb sg; + + if (!shell && event_ctrl_is_down(event)) { + /* Control code assignments may change, so reread them. */ + if (ioctl (pty_fd, TIOCGLTC, <) != -1) { + t_suspc = lt.t_suspc; + t_dsuspc = lt.t_dsuspc; + } + + /* Echo but ignore suspend control characters if not in raw mode. */ + if (key == t_suspc || key == t_dsuspc) { + if (ioctl(pty_fd,TIOCGETP,&sg) != -1 && (!(sg.sg_flags&RAW))) { + char out[2]; + out[0] = '^'; + out[1] = (key & 077) + '@'; + ttysw_output (gt_ttysw, out, 2); + return (1); + } + } + } + + return (0); +} + + +/* EV_TTYFRAME -- TTY frame event handler. + */ +static Notify_value +ev_ttyframe (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + Notify_value value; + static int ignore_resize = 1; + + /* Let frame operate upon the event. */ + value = notify_next_event_func (frame, event, arg, type); + + if (event_id(event) == WIN_RESIZE) { + /* Tty_adjustheight, if it resizes the window, will cause a resize + * event to be queued and we will be called back. Set a flag to + * ignore this event or an infinite loop will result. + */ + if (ignore_resize) + ignore_resize = 0; + else { + ignore_resize = 1; + tty_adjustheight (0); + } + } + + return (value); +} + + +/* TTY_ADJUSTHEIGHT -- Called when the tty window is initially sized or when + * it is dynamically resized to adjust the size to an integral number of lines + * and allow space for the panel at the top (this is NOT done when the tty + * window resizes itself, although it should be). + */ +static +tty_adjustheight (nrows) +int nrows; +{ + struct pixfont *pf; + int height; + + if (nrows == 0) + nrows = (int) window_get (gt_ttysw, WIN_ROWS); + + pf = (struct pixfont *) window_get (gt_baseframe, WIN_FONT); + height = HEIGHTADJUST + pf->pf_defaultsize.y * nrows + 1; + + if (height != (int) window_get (gt_baseframe, WIN_HEIGHT)) + window_set (gt_baseframe, WIN_HEIGHT, height, 0); +} + + +/* GIO_OPEN_WORKSTATION -- Called by the low level gtermio code when there is + * output to the graphics frame but the frame is in a closed state. + */ +gio_open_workstation() +{ + cursor_used = 0; + gio_setcursor (CURSOR_OFF, 0); + if (openws_action == NO_ACTION) + return; + + if (!gio_frame_has_moved) + window_set (gio_frame, + WIN_HEIGHT, win_ysize + (TOOL_BORDERWIDTH * 2), + WIN_WIDTH, win_xsize + (TOOL_BORDERWIDTH * 2), + WIN_X, win_xoff, + WIN_Y, win_yoff, + 0); + + switch (openws_action) { + case SHOW_FRAME: + window_set (gio_frame, WIN_SHOW, TRUE, 0); + break; + case EXPOSE_FRAME: + set_coverwindow (gio_frame, gt_baseframe); + break; + } + + /* If the setup panel is on, move it to the top. */ + if ((int) window_get (setup_frame, WIN_SHOW) == TRUE) + window_set (setup_frame, WIN_SHOW, TRUE, 0); +} + + +/* GIO_CLOSE_WORKSTATION -- Called by the low level gtermio code when the CAN + * sequence is received, to turn off or hide the now inactive graphics window. + */ +gio_close_workstation() +{ + if (cursor_used) + window_set (gt_ttysw, WIN_MOUSE_XY, tty_lastx, tty_lasty, 0); + gio_setcursor (CURSOR_ON, CROSSHAIR_OFF); + + if (closews_action != NO_ACTION) + if (closews_pause && !pause_mode && !cursor_used) { + show_pausepanel (1); + pause_mode = 1; + return; + } + + /* If the window has been closed, do nothing. */ + if (window_get (gio_frame, WIN_SHOW)) + switch (closews_action) { + case UNSHOW_FRAME: + window_set (gio_frame, WIN_SHOW, FALSE, 0); + break; + case HIDE_FRAME: + set_coverwindow (gt_baseframe, gio_frame); + break; + } + + pause_mode = 0; +} + + +/* SET_COVERWINDOW -- Make the first window cover the second if they overlap. + */ +static +set_coverwindow (win_top, win_bot) +Frame win_top, win_bot; +{ + int fd_top, fd_bot; + + fd_top = (int) window_get (gt_baseframe, WIN_FD); + fd_bot = (int) window_get (gio_frame, WIN_FD); + + win_lockdata (fd_top); + win_lockdata (fd_bot); + win_remove (fd_bot); + win_setlink (fd_bot, WL_COVERING, win_fdtonumber(fd_top)); + win_insert (fd_bot); + win_unlockdata (fd_bot); + win_unlockdata (fd_top); +} + + +/* EV_GIOFRAME -- GIO frame event handler. + */ +static Notify_value +ev_gioframe (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + Notify_value value; + int o_xoff, o_yoff, n_xoff, n_yoff; + + o_xoff = (int) window_get (gio_frame, WIN_X); + o_yoff = (int) window_get (gio_frame, WIN_Y); + + /* Let frame operate upon the event. */ + value = notify_next_event_func (frame, event, arg, type); + + n_xoff = (int) window_get (gio_frame, WIN_X); + n_yoff = (int) window_get (gio_frame, WIN_Y); + + /* Determine if the graphics window has been moved by the user. + * If so, we don't want to move it ourselves any more. + */ + if (n_xoff != o_xoff || n_yoff != o_yoff) { + gio_frame_has_moved = 1; + win_xoff = n_xoff; + win_yoff = n_yoff; + } + + return (value); +} + + +/* EV_GIOINPUT -- GIO input event handler. + */ +static Notify_value +ev_gioinput (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + register int key; + Notify_value value; + char ch; + + /* If we are pausing for input before closing the workstation, + * complete the close workstation operation and discard the event. + */ + if (pause_mode && (event_is_ascii(event) || event_is_button(event))) { + show_pausepanel (0); + gio_close_workstation(); + return (NOTIFY_DONE); + } + + /* Let frame operate upon the event. */ + value = notify_next_event_func (frame, event, arg, type); + + switch (key = event_id (event)) { + case WIN_RESIZE: + win_xsize = (int) window_get (gio_frame, WIN_WIDTH) - + (TOOL_BORDERWIDTH * 2); + win_ysize = (int) window_get (gio_frame, WIN_HEIGHT) - + (TOOL_BORDERWIDTH * 2); + if (!gio_frame_has_moved) { + win_xoff = (int) window_get (gio_frame, WIN_X); + win_yoff = (int) window_get (gio_frame, WIN_Y); + } + + if (!cursor_read_pending) + gio_setcursor (CROSSHAIR_OFF, CURSOR_ON); + + gio_getbestfont (win_xsize, win_ysize); + gio_reset (DEF_TEKXRES, DEF_TEKYRES, alpha_font, text_font); + break; + + case MS_RIGHT: + /* When a cursor read is not in progress, i.e., the gio window + * is idle, the right mouse button will cause the crosshairs to + * be displayed while the button is held down and the cursor is + * in the graphics window. During a cursor read the right button + * may be used to alias a key, like the left and middle buttons + * below. + */ + if (cursor_read_pending && event_is_down(event)) { + if (event_ctrl_is_down (event)) + key_right = last_key; + else if (key = key_right) + goto readcur; + } else if (!cursor_read_pending) { + if (event_is_down (event)) + gio_setcursor (CROSSHAIR_ON, CURSOR_ON); + else + gio_setcursor (CROSSHAIR_OFF, 0); + } + break; + + case MS_LEFT: + case MS_MIDDLE: + /* The left and middle mouse buttons may be used while in the + * graphics window to alias keyboard events. Typing ctrl/button + * causes the last key to be aliased with the indicated button. + * Thereafter, pressing that mouse button during a cursor read + * causes the cursor read to terminate, returning the aliased + * key just as if the key had been typed on the keyboard. + */ + if (event_is_down (event)) + if (event_ctrl_is_down (event)) { + if (key == MS_LEFT) + key_left = last_key; + else + key_middle = last_key; + } else if (cursor_read_pending) { + if (key == MS_LEFT) + key = key_left; + else + key = key_middle; + if (key) + goto readcur; + } + break; + + case KEY_TOP(7): + /* Toggle full screen graphics mode. + */ + if (event_is_down(event)) + toggle_fullscreen(); + break; + + case KEY_TOP(8): + /* Clear the graphics screen, leaving the terminal in graphics + * mode. + */ + if (event_is_down(event) && !cursor_read_pending) { + char buf[3]; + + buf[0] = '\035'; + buf[1] = '\033'; + buf[2] = '\014'; + ev_ptyoutput (buf, 3); + } + break; + + case KEY_TOP(9): + case KEY_LEFT(7): + /* Exit graphics mode, returning to text mode. + */ + if (event_is_down(event) && !cursor_read_pending) { + char buf[1]; + + /* + window_set (gt_ttysw, + WIN_IGNORE_KBD_EVENTS, KEY_TOP(9), 0, + 0); + */ + + if (key == KEY_LEFT(7)) /* delay CW until after L7 */ + gio_pause (500); + + cursor_used++; /* disable pause on CW */ + buf[0] = '\030'; + ev_ptyoutput (buf, 1); + } + break; + + default: + /* Terminate a cursor read, returning the encoded cursor value + * sequence to the terminal output. + */ + if (event_is_down(event) && + (event_is_ascii(event) || event_is_key_right(event))) { + + /* Ignore control codes if -ignore set? */ + if (iscntrl(key) && key != '\r' && ignore_inputevent(event)) + return (value); + + /* Terminate cursor read? */ + if (cursor_read_pending) { + /* Map keypad function keys to digits. */ + if (event_is_key_right(event)) { + switch (key = event_id(event) - KEY_RIGHT(1) + 1) { + case 7: case 8: case 9: + break; + case 10: case 11: case 12: + key -= 6; + break; + case 13: case 14: case 15: + key -= 12; + break; + default: + return (value); + } + key += '0'; + } +readcur: + last_x = event_x (event); + last_y = event_y (event); + last_key = key; + + cursor_read_pending = 0; + gio_setcursor (CURSOR_OFF, CROSSHAIR_OFF); + gio_retcursor (key, last_x, last_y); + enable_arrow_keys(); + + } else + write (pty_fd, (ch=key, &ch), 1); + } + } + + return (value); +} + + +/* SIG_TSTP -- Signal handler for signal SIGTSTP. + */ +static Notify_func +sig_tstp() +{ + kill (getpid(), SIGSTOP); +} + + +/* RESTART_CHILDPGRP -- Send the SIGCONT signal to the process group + * associated with this terminal, e.g., to restart the processes after + * the user has accidentally typed the stop character. + */ +static +restart_childpgrp() +{ + int pgrp; + + ioctl (pty_fd, TIOCGPGRP, &pgrp); + killpg (pgrp, SIGCONT); +} + + +/* GIO_GETBESTFONT -- Scan the font table and open the tek-alpha font which + * best fits the given size window. The important dimension is the window + * width, since the character spacing is fixed. Also pick a text (status + * line) font small enough to provide space for at least 80 chars. + */ +static +gio_getbestfont (xsize, ysize) +int xsize, ysize; /* canvas size, x,y */ +{ + register struct fonttab *ft, *o_ft; + register int i; + struct pixfont *newfont; + char pathname[256]; + + /* Select tek-alpha font. + */ + for (i=0, o_ft=ft=alpha_fonts; ft->pointsize != 0; o_ft=ft++, i++) + if (ft->win_xsize > xsize) + break; + + if (i == 0) + i = 1; + + sprintf (pathname, o_ft->path, o_ft->pointsize); + if ((newfont = pf_open (pathname)) == NULL) { + fprintf (stderr, "cannot open font %s\n", pathname); + return (-1); + } else if (alpha_font != NULL) + pf_close (alpha_font->pixfont); + + alpha_font = o_ft; + alpha_font->pixfont = newfont; + alpha_font_index = i - 1; + + /* Load the text (status line) font. + */ + o_ft = &text_fonts[i-1]; + sprintf (pathname, o_ft->path, o_ft->pointsize); + if ((newfont = pf_open (pathname)) == NULL) { + fprintf (stderr, "cannot open font %s\n", pathname); + return (-1); + } else if (text_font != NULL) + pf_close (text_font->pixfont); + + text_font = o_ft; + text_font->pixfont = newfont; + text_font_index = i - 1; + + return (0); +} + + +/* GIO_SETCURSOR -- Set graphics frame cursor options. + */ +gio_setcursor (op1, op2) +int op1, op2; +{ + Cursor cursor; + int option[2], i; + int type=cursor_type, show=cursor_show; + + /* Normalize the argument list. */ + for (option[0]=op1, option[1]=op2, i=0; i < 2; i++) + switch (option[i]) { + case CROSSHAIR_OFF: + case CROSSHAIR_ON: + type = option[i]; + break; + case CURSOR_OFF: + case CURSOR_ON: + show = option[i]; + break; + } + + /* Do we need to change anything? */ + if (type == cursor_type && show == cursor_show) + return; + + /* Modify the cursor attributes. */ + cursor = window_get (gio_canvas, WIN_CURSOR); + cursor_set (cursor, + CURSOR_SHOW_CURSOR, FALSE, + CURSOR_SHOW_CROSSHAIRS, (show==CURSOR_ON) ? TRUE : FALSE, + CURSOR_CROSSHAIR_THICKNESS, 1, + CURSOR_CROSSHAIR_LENGTH, (type==CROSSHAIR_ON) ? CURSOR_TO_EDGE : 10, + CURSOR_CROSSHAIR_OP, PIX_SRC, + CURSOR_CROSSHAIR_COLOR, 1, + 0); + window_set (gio_canvas, WIN_CURSOR, cursor, 0); + + cursor_type = type; + cursor_show = show; +} + + +/* GIO_SETCURSORPOS -- Set the position of the graphics cursor within the + * graphics frame. + */ +gio_setcursorpos (x, y) +int x, y; /* pixwin pixel coords */ +{ + window_set (gio_canvas, WIN_MOUSE_XY, x, y, 0); + last_x = x; + last_y = y; + cursor_used++; +} + + +/* GIO_READCURSOR -- Initiate a cursor read. Set the cursor type to + * a full crosshair cursor to indicate to the user that the program is + * waiting for cursor input. Set the cursor read pending flag so that + * the next input event in graphics window will cause termination of the + * cursor read and transmission of the cursor value to the terminal output. + */ +gio_readcursor() +{ + /* When a cursor read is initiated, move the cursor into the gio + * window so that the user knows that cursor input is expected. + */ + if (last_x < 0) { + last_x = win_xsize / 2; + last_y = win_ysize / 2; + } + + /* Disable the mapping of the right function keys to the ansi arrow + * key escape sequences, since we want to receive these keys as + * function key events. + */ + disable_arrow_keys(); + + gio_setcursorpos (last_x, last_y); + gio_setcursor (CURSOR_ON, CROSSHAIR_ON); + cursor_read_pending++; + cursor_used++; +} + + +/* TOGGLE_GRAPHICS -- Show or hide the graphics frame. + */ +static +toggle_graphics() +{ + if ((int) window_get (gio_frame, WIN_SHOW) == TRUE) + window_set (gio_frame, WIN_SHOW, FALSE, 0); + else { + if (!gio_frame_has_moved) + window_set (gio_frame, + WIN_HEIGHT, win_ysize + (TOOL_BORDERWIDTH * 2), + WIN_WIDTH, win_xsize + (TOOL_BORDERWIDTH * 2), + WIN_X, win_xoff, + WIN_Y, win_yoff, + 0); + window_set (gio_frame, WIN_SHOW, TRUE, 0); + + /* If the setup panel is on, move it to the top. */ + if ((int) window_get (setup_frame, WIN_SHOW) == TRUE) + window_set (setup_frame, WIN_SHOW, TRUE, 0); + } +} + + +/* RESET_PROC -- Called from the setup panel to reset the state of the + * terminal. + */ +static +reset_proc() +{ + /* Cancel any pending cursor read. */ + if (cursor_read_pending) { + gio_retcursor ('\r', 0, 0); + enable_arrow_keys(); + } + + /* Cancel logging if enabled. */ + if (gt_logfp) { + fclose (gt_logfp); + gt_logfp = NULL; + menu_set (logitem, MENU_STRING, "Logging on", 0); + } + + /* Restore user settable options. */ + restore_params(); + + /* Reset internal state variables. */ + cursor_type = -1; /* crosshair or small cursor */ + cursor_show = -1; /* cursor on or off */ + cursor_read_pending = 0; /* waiting for cursor event */ + key_left = 0; /* key aliased to left msbutton */ + key_middle = 0; /* key aliased to mid msbutton */ + key_right = 0; /* key aliased to mid msbutton */ + last_key = 0; /* last cursor read key */ + last_x= -1,last_y= -1; /* last cursor read position */ + setup_xoff = 150; /* offset to setup panel */ + setup_yoff = 150; + red[0] = green[0] = 0; + red[1] = green[1] = 255; + blue[0] = 128; blue[1] = 0; + gio_frame_has_moved = 0; + pause_mode = 0; + cursor_used = 0; + + /* Reset internal state. */ + notify_remove_event_func (gio_canvas, ev_gioinput, NOTIFY_SAFE); + notify_remove_event_func (gio_frame, ev_gioframe, NOTIFY_SAFE); + window_destroy (gio_frame); + parse_args (main_argc, main_argv, + &tty_argc, tty_argv, &gio_argc, gio_argv); + create_gio_popup (gio_argc, gio_argv); + notify_interpose_event_func (gio_frame, ev_gioframe, NOTIFY_SAFE); + notify_interpose_event_func (gio_canvas, ev_gioinput, NOTIFY_SAFE); + gio_setup (pty_fd, pw); + gio_hardreset (DEF_TEKXRES, DEF_TEKYRES, alpha_font, text_font); + gio_enable (graphics_enable); + + if (pause_frame) + window_destroy (pause_frame); + + window_destroy (setup_frame); + create_setup_popup (0, NULL); + panel_set_item(); + window_set (setup_frame, WIN_SHOW, TRUE, 0); +} + + +/* SAVE_PARAMS -- Save the user settable options. + */ +static +save_params() +{ + s_clip_graphics = clip_graphics; + s_graphics_enable = graphics_enable; + s_openws_action = openws_action; + s_closews_action = closews_action; + s_closews_pause = closews_pause; + s_canvas_retained = canvas_retained; + s_reverse_video = reverse_video; + s_color = color; + s_win_xsize = win_xsize; + s_win_ysize = win_ysize; + s_win_xoff = win_xoff; + s_win_yoff = win_yoff; + s_ignore = ignore; + strcpy (s_gin_modeterm, gin_modeterm); +} + + +/* RESTORE_PARAMS -- Restore the user settable options. + */ +static +restore_params() +{ + clip_graphics = s_clip_graphics; + graphics_enable = s_graphics_enable; + openws_action = s_openws_action; + closews_action = s_closews_action; + closews_pause = s_closews_pause; + canvas_retained = s_canvas_retained; + reverse_video = s_reverse_video; + color = s_color; + win_xsize = s_win_xsize; + win_ysize = s_win_ysize; + win_xoff = s_win_xoff; + win_yoff = s_win_yoff; + ignore = s_ignore; + + strcpy (gin_modeterm, s_gin_modeterm); + gio_setginmodeterm (gin_modeterm); +} + + +/* CLEAR_PROC -- Called when the clear button is clicked to transmit the + * screen clear sequence to the TTY subwindow. + */ +static +clear_proc() +{ + static char clearscreen[] = "\f"; + ttysw_output (gt_ttysw, clearscreen, strlen(clearscreen)); +} + + +/* GCLEAR_PROC -- Called when the gclear button is clicked to clear the + * graphics window. + */ +static +gclear_proc() +{ + static char clearscreen[] = "\035\033\f"; + ev_ptyoutput (clearscreen, strlen(clearscreen)); +} + + +/* PRINT_USAGE -- Print instructions on how to use this window tool. + */ +static +print_usage (toolname) +char *toolname; +{ + char *bstyle = "[-B boldstyle] "; + + fprintf (stderr, + "syntax: %s [-C] %s[program [args]]\n", toolname, bstyle); + fprintf (stderr, + "-C redirect console output to this instance of %s\n", toolname); + fprintf (stderr, + "-B set boldstyle for this instance of %s\n", toolname); + fprintf (stderr, + " where boldstyle is a number from 1 to 8\n"); + fprintf (stderr, + "-I input the next argument to the shell run from %s\n", toolname); +} diff --git a/unix/sun/gterm.esc b/unix/sun/gterm.esc new file mode 100644 index 00000000..a557bd73 --- /dev/null +++ b/unix/sun/gterm.esc @@ -0,0 +1,46 @@ +/* + * GTERM.ESC -- Macros and data defining the escape sequences recognized by + * the graphics terminal. Ambiguous cases are resolved in favor of the + * entry which occurs first in the table. + */ +#define ESC_SETTEXTMODE 1 +#define ESC_ENQUIRE 2 +#define ESC_READCURSOR 3 +#define ESC_CLEARSCREEN 4 +#define ESC_SETCURSOR 5 +#define ESC_SETCHARSIZE0 6 +#define ESC_SETCHARSIZE1 7 +#define ESC_SETCHARSIZE2 8 +#define ESC_SETCHARSIZE3 9 +#define ESC_SETDATALEVEL0 10 +#define ESC_SETDATALEVEL1 11 +#define ESC_SETDATALEVEL2 12 +#define ESC_SETLINESTYLE0 13 +#define ESC_SETLINESTYLE1 14 +#define ESC_SETLINESTYLE2 15 +#define ESC_SETLINESTYLE3 16 +#define ESC_SETLINESTYLE4 17 +#define ESC_SETLINEWIDTH0 18 +#define ESC_SETLINEWIDTH1 19 +#define ESC_SETLINEWIDTH2 20 + +ESC_SETTEXTMODE, 015, 000, 000, 000, 000, 000, 0, +ESC_ENQUIRE, ENQ, 000, 000, 000, 000, 000, 0, +ESC_READCURSOR, SUB, 000, 000, 000, 000, 000, 0, +ESC_CLEARSCREEN, 014, 000, 000, 000, 000, 000, 0, +ESC_SETCURSOR, '/', 'f', 000, 000, 000, 000, 0, +ESC_SETCHARSIZE0, '0', 000, 000, 000, 000, 000, 0, +ESC_SETCHARSIZE1, '1', 000, 000, 000, 000, 000, 0, +ESC_SETCHARSIZE2, '2', 000, 000, 000, 000, 000, 0, +ESC_SETCHARSIZE3, '3', 000, 000, 000, 000, 000, 0, +ESC_SETDATALEVEL0, '/', '0', 'd', 000, 000, 000, 0, +ESC_SETDATALEVEL1, '/', '1', 'd', 000, 000, 000, 0, +ESC_SETDATALEVEL2, '/', '2', 'd', 000, 000, 000, 0, +ESC_SETLINESTYLE0, '`', 000, 000, 000, 000, 000, 0, +ESC_SETLINESTYLE1, 'a', 000, 000, 000, 000, 000, 0, +ESC_SETLINESTYLE2, 'b', 000, 000, 000, 000, 000, 0, +ESC_SETLINESTYLE3, 'c', 000, 000, 000, 000, 000, 0, +ESC_SETLINESTYLE4, 'd', 000, 000, 000, 000, 000, 0, +ESC_SETLINEWIDTH0, '/', '0', 'w', 000, 000, 000, 0, +ESC_SETLINEWIDTH1, '/', '1', 'w', 000, 000, 000, 0, +ESC_SETLINEWIDTH2, '/', '2', 'w', 000, 000, 000, 0, diff --git a/unix/sun/gterm.h b/unix/sun/gterm.h new file mode 100644 index 00000000..121587ae --- /dev/null +++ b/unix/sun/gterm.h @@ -0,0 +1,18 @@ +/* GTERM.H -- Global definitions for GTERM. + */ +#define CURSOR_OFF 3 /* turn cursor off entirely */ +#define CURSOR_ON 4 /* turn it back on */ + +#define GRAPHICS_OFF 0 +#define GRAPHICS_ON 1 +#define GRAPHICS_DISCARD 2 + + +struct fonttab { /* Gterm font descriptor. */ + short pointsize; + char ch_xsize, ch_ysize; + short win_xsize, win_ysize; + struct pixfont *pixfont; + char *path; + char *label; +}; diff --git a/unix/sun/gterm.icon b/unix/sun/gterm.icon new file mode 100644 index 00000000..05c634a6 --- /dev/null +++ b/unix/sun/gterm.icon @@ -0,0 +1,34 @@ +/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16 + */ + 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xF3FF,0xFFFF,0xFFFF, + 0xFFFF,0xF0FF,0xFFFF,0xFFFF,0xFFFF,0xF03F,0xFFFF,0xFFFF, + 0xFFFF,0xE01F,0xFFFF,0xFFFF,0xFFFF,0xE00F,0xFFFF,0xFFFF, + 0xFFFF,0xE007,0xFFFF,0xFFFF,0xFFFF,0xE003,0xFFFF,0xFFFF, + 0xFFFF,0xE103,0xFFFF,0xFFFF,0xFFFF,0xE101,0xFFFF,0xFFFF, + 0xFFFF,0xC181,0x3FFF,0xFFFF,0xFFFF,0xC181,0x9FFF,0xFFFF, + 0xFFFF,0xC1C1,0x8FFF,0xFFFF,0xFFFF,0xC1C1,0x87FF,0xFF8F, + 0xFFFF,0xC1C0,0x8307,0xFE1F,0xFFFE,0xC1E0,0x8180,0x001F, + 0xFFFC,0xC1E0,0xC0C0,0x00FF,0xFFF8,0x81E0,0xC0C0,0x3FFF, + 0xFFE0,0x81E0,0xC060,0x1DFF,0xFE01,0x81E0,0xC030,0x11FF, + 0xF001,0x81E0,0xC038,0x03FF,0x8001,0x81C0,0xC018,0x07FF, + 0x8001,0x8180,0xC00C,0x03FF,0x8001,0x0100,0xC006,0x03FF, + 0xFC01,0x0001,0xC007,0x01FF,0xFF81,0x0001,0xC083,0x03FF, + 0xFFE3,0x0007,0xC0C1,0x87FF,0xFFF3,0x0007,0xC060,0xDFFF, + 0xFFF3,0x0007,0xC030,0xFFFF,0xFFFB,0x0003,0xC030,0x7FFF, + 0xFFFE,0x0003,0xC018,0x3FFF,0xFFFE,0x0001,0xC018,0x1FFF, + 0xFFFE,0x0001,0xC00C,0x1FFF,0xFFFE,0x0000,0xC00C,0x0FFF, + 0xFFFE,0x0000,0xC00E,0x0FFF,0xFFFE,0x0000,0x4006,0x07FF, + 0xFFFC,0x0000,0xC006,0x07FF,0xFFFC,0x0001,0xC007,0x03FF, + 0xFFFC,0x0003,0xE007,0x03FF,0xFFFC,0x0187,0xF007,0x01FF, + 0xFFF8,0x01EF,0xF807,0x01FF,0xFFF8,0x01FF,0xF807,0x80FF, + 0xFFF0,0x01FF,0xFC07,0x80FF,0xFFF0,0x01FF,0xFF07,0x80FF, + 0xFFF0,0x01FF,0xFF81,0x807F,0xFFF0,0x03FF,0xFFC0,0x007F, + 0xFFF0,0x07FF,0xFFE6,0x007F,0xFFE0,0x07FF,0xFFF7,0x803F, + 0xFFE0,0x0FFF,0xFFFF,0x803F,0xFFE0,0x1FFF,0xFFFF,0x801F, + 0xFFE0,0x3FFF,0xFFFF,0x800F,0xFFC0,0x3FFF,0xFFFF,0x800F, + 0xFFC0,0x7FFF,0xFFFF,0x800F,0xFFC0,0xFFFF,0xFFFF,0xE007, + 0xFFC1,0x8000,0x0000,0xF007,0xFF81,0x8040,0x0000,0xF803, + 0xFF83,0x9CF1,0x8A34,0xFC03,0xFF87,0xA442,0x4D2A,0xFF03, + 0xFF8F,0xA443,0x882A,0xFF81,0xFF9F,0x9C42,0x082A,0xFFE1, + 0xFF1F,0x8431,0xC82A,0xFFF1,0xFF3F,0xB800,0x0000,0xFFF9, + 0xFF7F,0x8000,0x0000,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF diff --git a/unix/sun/gterm.icon.OLD b/unix/sun/gterm.icon.OLD new file mode 100644 index 00000000..6a40db4b --- /dev/null +++ b/unix/sun/gterm.icon.OLD @@ -0,0 +1,34 @@ +/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16 + */ + 0x8888,0x8888,0x8888,0x8888,0x8888,0x889F,0xFC88,0x8888, + 0x2222,0x23FF,0xFFE2,0x2222,0x2222,0x27FF,0xFFF2,0x2222, + 0x8888,0xBFFF,0xFFFE,0x8888,0x8888,0xFFFF,0xFFFF,0x8888, + 0x2223,0xFFFF,0xFFFF,0xE222,0x2223,0xFFF0,0x07FF,0xE222, + 0x888F,0xFF00,0x007F,0xF888,0x888F,0xFC00,0x001F,0xF888, + 0x223F,0xF000,0x0007,0xFE22,0x223F,0xE000,0x0003,0xFE22, + 0x88FF,0x8000,0x0000,0xFF88,0x88FF,0x0000,0x0000,0x7F88, + 0x23FE,0x0000,0x0000,0x3FE2,0x23FC,0x0000,0x0000,0x1FE2, + 0x8BF8,0x0000,0x0000,0x0FE8,0x8FF8,0x0000,0x0000,0x0FF8, + 0x27F0,0x0000,0x0000,0x07F2,0x27E0,0x0000,0x0000,0x03F2, + 0x8FE0,0x0000,0x0000,0x03F8,0x8FC0,0x0000,0x0000,0x01F8, + 0x3FC0,0x0000,0x0000,0x01FE,0x3F80,0x0000,0x0000,0x00FE, + 0x9F80,0x0000,0x0000,0x00FC,0x9F83,0xE3F0,0x1C3F,0xC0FC, + 0x3F81,0xC1D8,0x1C1C,0xC0FE,0x3F01,0xC1DC,0x1C1C,0x007E, + 0xBF01,0xC1DC,0x1C1C,0x007E,0xBF01,0xC1D8,0x3E1F,0x007E, + 0x3F01,0xC1F0,0x3E1F,0x007E,0x3F01,0xC1F0,0x3E1F,0x007E, + 0xBF01,0xC1F8,0x3E1C,0x007E,0xBF01,0xC1F8,0x671C,0x007E, + 0x3F01,0xC1DE,0x671C,0x007E,0x3F03,0xE3EE,0xFFBE,0x007E, + 0xBF80,0x0000,0x0000,0x00FE,0x9F80,0x0000,0x0000,0x00FC, + 0x3F80,0x0000,0x0000,0x00FE,0x3F80,0x0000,0x0000,0x00FE, + 0x9FC0,0x0000,0x0000,0x01FC,0x8FC0,0x0000,0x0000,0x01F8, + 0x2FE0,0x0000,0x0000,0x03FA,0x27E0,0x0000,0x0000,0x03F2, + 0x8FF0,0x0000,0x0000,0x07F8,0x8FF8,0x0000,0x0000,0x0FF8, + 0x23F8,0x0000,0x0000,0x0FE2,0x23FC,0x0000,0x0000,0x1FE2, + 0x89FE,0x0000,0x0000,0x3FC8,0x88FF,0x0000,0x0000,0x7F88, + 0x227F,0x8000,0x0000,0xFF22,0x223F,0xE000,0x0003,0xFE22, + 0x889F,0xF000,0x0007,0xFC88,0x888F,0xFC00,0x001F,0xF888, + 0x2227,0xFF00,0x007F,0xF222,0x2223,0xFFF0,0x07FF,0xE222, + 0x8889,0xFFFF,0xFFFF,0xC888,0x8888,0xFFFF,0xFFFF,0x8888, + 0x2222,0x3FFF,0xFFFE,0x2222,0x2222,0x27FF,0xFFF2,0x2222, + 0x8888,0x89FF,0xFFC8,0x8888,0x8888,0x889F,0xFC88,0x8888, + 0x2222,0x2222,0x2222,0x2222,0x2222,0x2222,0x2222,0x2222 diff --git a/unix/sun/gterm.man b/unix/sun/gterm.man new file mode 100644 index 00000000..fd09b5f4 --- /dev/null +++ b/unix/sun/gterm.man @@ -0,0 +1,784 @@ +.\" @(#)gterm.1 1.1 28-Jul-87 DCT +.TH GTERM 1 "31 December 1987" +.SH NAME +gterm \- virtual graphics terminal for the SunView environment +.SH SYNOPSIS +.B gterm +[ +.B \-C +] +[ +.B \-T +] +[ +.B \-B +\fIboldstyle\fR +] +[ +.B \-I +\fIcommand\fR +] +.if n .ti +0.5i +[ +.B \-ignore +] +[ +\fIttyargs\fR +] +.ti +.5i +[ +.B \-G +[ +.B \-Gopen +\fR(\fP\fBnoaction\fR | \fBshow\fR | \fBexpose\fR\fR)\fP +] +.if n .ti +1.0i +[ +.B \-Gclose +\fR(\fP\fBnoaction\fR | \fBblank\fR | \fBhide\fR\fR)\fP +] +.ne 4 +.ti +1.0i +[ +.B \-\fR[\fPno\fR]\fPpause +] +[ +.B \-\fR[\fPno\fR]\fPretain +] +[ +.B \-\fR[\fPno\fR]\fPclip +] +.if n .ti +1.0i +[ +.B \-\fR[\fPno\fR]\fPreverse +] +[ +.B \-color +| +.B \-mono +] +.ti +1.0i +[ +.B \-ginterm +\fR[\fIchar \fR[\fIchar\fR]] +] +[ +\fIgioargs\fR +] +] +.ti +.5i +[ +\fIprogram\fR +[ +\fIargs\fR +] +] +.SH GETTING STARTED +\fIgterm\fR is a virtual graphics terminal implemented as a set of windows +running within the SunView environment. The graphics terminal consists of +two primary windows, the main \fBtext window\fR and a \fBgraphics subwindow\fR. +The text window is a standard SunView TTY subwindow, identical to that used +in \fIshelltool\fR. The graphics window is a Tektronix 4012 compatible +graphics window. The two windows may be moved and sized independently. +Terminal i/o may be directed to either window, but to only +one window at a time. When i/o is directed to the text window the terminal +is said to be in \fBtext mode\fR, and when i/o is directed to the graphics +window the terminal is said to be in \fBgraphics mode\fR. Mode switching +may be performed either manually or under program control. +\fIgterm\fR is upwards compatible with \fIshelltool\fR. +.SH OPTIONS +.TP +.B \-C +Redirect system console output to this instance of \fIgterm\fR. +.TP +.B \-T +Run \fIgterm\fR with the graphics plane disabled. Any graphics commands +embedded in the input data stream will appear as printable characters in the +text window. This option is useful when using \fIgterm\fR for a nongraphics +session over a noisy line, or when debugging a graphics program and switching +back and forth between text and graphics mode would interfere with the +operation of the debugger. +.TP +\fB\-B\fP \fIboldstyle\fR +Sets the \fIboldstyle\fR +(rendering of boldface type in the text window) +for this instance of \fIgterm\fR. +The choices are the same as for any tool based +on a SunView tty subwindow: see \fIshelltool\fR(1) for a description of the +\fIboldstyle\fR options. +.TP +\fB\-I\fP \fIcommand\fR +Input the given command to the program or shell run in the \fIgterm\fR window, +as if it had been typed into the window. Spaces in the command must be +escaped, or the command string must be quoted. +.TP +.B \-ignore +Ignore the suspend control characters (SIGTSTP), \fIif\fR the process being +run in the \fIgterm\fR window is not the default SHELL process. +If this option is in effect, typing one of the \fIstty\fR suspend-process +control characters \fBsusp\fR or \fBdsusp\fR while the terminal is not in raw +mode will cause the character to be echoed in the text window, but to be +otherwise ignored. This may be desirable if the process being run in the +\fIgterm\fR window is not capable of restarting itself after it has been +suspended (see also the \fBcontinue\fR frame menu option). +.TP +\fIttyargs\fR +\fIgterm\fR also takes generic tool arguments; see \fIsuntools\fR(1) for a +list of these arguments. The \fIttyargs\fR generic tool arguments affect +only the text window. +.TP +.B \-G +Generic tool arguments preceding this optional placeholder switch affect only +the text window; those following the switch affect only the graphics window. +.TP +\fB-Gopen \fR(\fPnoaction \fR|\fP show \fR|\fP expose\fR)\fP +Specifies the action to be taken when graphics mode is entered, i.e., when +terminal i/o is redirected from the text window to the graphics window. +\fBnoaction\fR means do nothing which visibly affects the screen. +\fBshow\fR means display the graphics frame if it is not already visible on +the screen, i.e., because the graphics window has been closed. +\fBexpose\fR means move the graphics window, if already displayed, to the +top of the stack of open windows. +.TP +\fB-Gclose \fR(\fPnoaction \fR|\fP blank \fR|\fP hide\fR)\fP +Specifies the action to be taken when graphics mode is exited, restoring +terminal i/o to the text window. +\fBnoaction\fR means do nothing which visibly affects the screen. +\fBblank\fR means close the graphics subwindow, causing the window to +disappear from the screen (the closed window can be redisplayed at any time +provided the contents are \fIretained\fR). +\fBhide\fR means move the graphics window to the bottom of the stack of +open windows. +.TP +\fB\-\fR[\fPno\fR]\fPpause +Pause before closing the graphics window and returning to text mode, +after opening the graphics frame to display a plot noninteractively +(no cursor reads). If \fB\-nopause\fR is specified and the \fB\-Gclose\fR +option is \fBblank\fR, a newly plotted graph will disappear immediately after +the plotting operation is completed, assuming no blocking operation such as +a cursor read occurs while in graphics mode. If \fB\-pause\fR is specified +\fIgterm\fR will detect this condition and pause for a keystroke to be typed +before exiting graphics mode. +.TP +\fB\-\fR[\fPno\fR]\fPretain +Specifies whether or not the contents of the graphics frame are to be retained. +If \fB\-noretain\fR is specified plotting will be somewhat faster, but any +window event which affects the region of the workstation screen occupied by +the graphics frame will cause the plot to be lost. +.TP +\fB\-\fR[\fPno\fR]\fPclip +Specifies whether or not clipping of graphics vectors is to be performed. +If \fB\-noclip\fR is specified plotting will be somewhat faster, but vectors +may be drawn outside the graphics window if the screen changes while a graph +is being drawn. +.TP +\fB\-\fR[\fPno\fR]\fPreverse +Specifies whether the graphics frame is to be displayed in normal or reverse +video. What constitutes normal video depends upon whether color or monochrome +is specified, and upon what has been specified for the foreground and +background colors. Reverse video swaps the foreground and background colors +within the graphics window. +.TP +.B \-color +Display the graphics frame in two colors, if \fIgterm\fR is run on a color +workstation. +.TP +.B \-mono +Display the graphics frame in monochrome, using the foreground and background +colors specified when \fIsuntools\fR(1) was started. +.TP +.B \-ginterm \fR[\fIchar \fR[\fIchar\fR]] +Set the GIN terminator character or characters (used to delimit the value +returned for a cursor read) to the indicated octal values \fIchar\fR. +If a \fIchar\fR value is omitted the corresponding GIN mode terminator will +be omitted when a cursor value is returned. For example, "\-ginterm" causes +both GIN delimiter characters to be omitted, and "\-ginterm 015" causes the +single GIN terminator character CR (carriage return) to be transmitted. +.TP +\fIgioargs\fR +\fIgterm\fR also takes generic tool arguments; see \fIsuntools\fR(1) for a +list of these arguments. The \fIgioargs\fR generic tool arguments affect +only the graphics subwindow, and are recognized only after the \fB\-G\fR +placeholder argument. +.TP +[\fIprogram\fP [\fIargs\fP]] +If a \fIprogram\fR argument is present, the named program is run in the +\fIgterm\fR window without spawning an intermediate shell. +If no \fIprogram\fR is specified, +\fIgterm\fR runs the shell specified by your \fLSHELL\fR environment +variable. If this environment variable is not defined, \fIgterm\fR runs +\fB/bin/sh\fR. +.LP +Minimum match abbreviations are permitted for all \fIgterm\fR arguments except +the generic tool arguments, which have two character aliases. Use of the full +names is however recommended, as the number of characters required for minimum +matching a specific argument may change in a future release of \fIgterm\fR +when new command line arguments are added. +.if t .sp 0.08i +.SH DESCRIPTION +.SS Virtual Graphics Terminal +.LP +\fIgterm\fR is a virtual graphics terminal implemented as a set of windows +running within the SunView environment. The terminal consists of two primary +windows, a \fBtext window\fR and a \fBgraphics window\fR, and several special +purpose subwindows, the most important of which is the \fBsetup panel\fR, +used to dynamically change \fIgterm\fR options at runtime, or to reset the +terminal to a known state. The virtual terminal is interfaced to applications +programs via the UNIX pseudoterminal or \fIpty\fR(4) interface, providing an +applications interface identical to that provided for ordinary terminals, +allowing applications running either on the local machine or on a remote +node communicating via a network interface (\fItelnet\fR, \fIrlogin\fR, +modem etc.) to communicate transparently with the \fIgterm\fR virtual terminal. +.if t .sp 0.08i +.SS Text Window +.LP +The text window is a standard SunView TTY subwindow, as used in +\fIshelltool\fR, \fIgfxtool\fR, and so on. Documentation for tty subwindows, +including both user documentation and a description of the special escape +sequences recognized by tty subwindows, is given in \fIshelltool\fR(1). +In particular, note that a \fB.ttyswrc\fR file may be placed in one's login +directory to set tty subwindow parameters, and to map function keys to control +sequences to be sent either to the tty subwindow or to the program running in +the tty subwindow. The \fBselection service\fR can be useful for passing +text to programs via the mouse instead of the keyboard, and numerous terminal +\fBescape sequences\fR are defined for resizing the text window, setting the +frame label, and so on. +.if t .sp 0.08i +.SS Graphics Window +The graphics window emulates a Tektronix 4012 terminal with minor differences, +e.g., the screen size is 35x80 rather than 35x75, and some significant +extensions, e.g., graphics and text can be selectively erased, and support +is provided for a \fBstatus line\fR at the bottom of the screen, in which text +can be dynamically read and written without affecting the contents of the +graphics plane. Although nonstandard, these features are very useful when +designing interactive user interfaces, and they can be emulated on most +modern graphics terminals (hence programs which use these features need not +be device dependent). +.LP +The position and size of the graphics window may be set at startup time via +the generic tool arguments \fIgioargs\fR. A number of preprogrammed sizes +may also be selected via the setup panel at runtime, or the mouse may be used +to directly resize the window to produce a window of any size and aspect ratio. +The standard graphics window sizes range from very small to the full screen +and all share the same standard landscape mode aspect ratio; users should note +that manually adjusting the window size usually results in a window with a +nonstandard aspect ratio, which may cause graphics programs which assume the +standard aspect ratio to misbehave, producing oddly shaped objects, or poorly +centered text strings. +.LP +\fIgterm\fR will automatically detect any changes in the size of the graphics +window, adjusting the transformation from 4012 coordinates (780x1024) to +screen coordinates so that subsequent graphics and text will be drawn at the +correct relative position within the window. The best text font for the new +window size is also selected; if the window is of an arbitrary size it will +not in general be possible to select a font which provides exactly 35x80 +characters on the screen without overlap, since there are only a limited number +of fixed size fonts to choose from. If the window is especially wide and +short text lines may overlap vertically. After resizing the graphics window, +the previously displayed graph \fImust\fR be redrawn under program control to +adjust the graph to fit the new window. +.LP +By default, the graphics window overlaps the text window, with eight or ten +characters of text visible to the left of the graphics window. If the graphics +window is left in its default position and the text window is repositioned on +the workstation screen, the graphics window will "track" the text window, +i.e., retain its position relative to the text window (this is desirable when +there are multiple instances of \fIgterm\fR in use at one time to avoid losing +track of which graphics frame goes with which text window). If the graphics +window is manually repositioned, however, then thereafter the positions of +the two windows are completely independent. +.LP +Although the graphics window is normally used only for graphics (plotting), +one should not forget that the graphics window emulates an (80 column wide) +Tektronix 4012 terminal, and hence may be used as a terminal for ordinary +text i/o, as well as for graphics. The TTY subwindow will normally be +superior for terminal graphics, but the extra page of text and the larger, +brighter font typically used in the graphics window may occasionally be useful +for some applications. Text i/o may easily be switched back and forth between +the text and graphics windows via the function keys described below, +transparently to most applications software. +.if t .sp 0.08i +.SS Active Window +.LP +At any one time, terminal output is always directed to either the text window +or the graphics window, but never to both at the same time. When output is +directed to the text window the terminal is said to be in \fBtext mode\fR, +and when output is directed to the graphics window the terminal is said to +be in \fBgraphics mode\fR, although either text or graphics may be written +into the graphics plane. Mode switching is normally in response to control +codes embedded in the input data stream from the applications program being +run, but keyboard function keys may be used to manually perform mode switching +if desired. +.LP +Keyboard \fIinput\fR may be directed to either window at any time, regardless +of which window is currently active, i.e., text may be typed into one window +but echoed in the other window. This can be confusing if the window in which +text is echoed is not currently displayed; one types and nothing seems to be +happening, but in fact commands are being input and executed normally. +For example, if the \fB\-Gclose\fR option is set to \fBnoaction\fR and the +graphics window is adjusted to fill the full screen, then when graphics mode +is exited terminal output will be directed to the text window, but the text +window will be covered by the graphics window, and subsequent commands and +textual output will not be visible without manually redisplaying the text +window (or undisplaying the graphics window) with a function key. +.if t .sp 0.08i +.SS The Frame Menu +.LP +\fIgterm\fR uses a special frame menu which may be called up by the mouse +at any time, by placing the cursor on the border of the \fItext window\fR and +holding down the right mouse button. +The items in the \fIgterm\fR frame menu are as follows: +.RS +.IP "\fBFrame\fP" 15 +Access the standard SunView frame menu. +.IP "\fBSetup\fP" +Display the setup panel. +.IP "\fBContinue\fP" +Send the SIGCONT signal to the process group attached to the \fIgterm\fR +window, e.g., after accidentally suspending a process which cannot otherwise +restart itself. See also the \fB\-ignore\fR command line option. +.IP "\fBShow graph\fP" +Display the graphics window. +.IP "\fBTextcopy\fP" +Make a hardcopy of the text window. +.IP "\fBGraphcopy\fP" +Make a hardcopy of the graphics window. +(IRAF users should use the cursor mode \fIsnap\fR function instead). +.IP "\fBScreencopy\fP" +Make a hardcopy of the full screen. +.RE +.LP +The textcopy, graphcopy, and screencopy selections are all entry points to the +general screen capture utility, discussed in the next section. +.if t .sp 0.08i +.SS Hardcopy Output +.LP +The hardcopy functions produce a "what you see is what you get" bitmap of the +rectangular region of the screen occupied by the indicated object of interest. +If the region of interest is partially covered by another window, then the +hardcopy will be a picture of a partially covered window. +If the window is displayed in reverse video, the hardcopy will also be +rendered in reverse video. +.LP +The screen capture software reads out the full memory of the workstation in +the region of interest, and in the case of a color workstation, processes the +screen pixels through the colortable to produce an image corresponding to what +appears on the screen. No full color output options +are currently provided, hence the average of the red, green, and blue color +values is next computed. If a bitmap output image is desired a simple +thresholding algorithm is used to produce the final bitmap image, +otherwise a greyscale image is produced. If rasterfile output +is being generated, the raw pixel values and RGB color table entries are saved +directly in the rasterfile, rather than applying the tables in software to +produce a monochrome or bitmap image. +.LP +Two output options are currently provided, i.e., \fBPostscript\fR output +suitable for output directly to a laser writer to produce the final graphics +hardcopy, or \fBSun rasterfile\fR output. The default action is to output a +Postscript program to the device "lw", e.g., the Apple Laserwriter +(any 300 dpi Postscript device should do). +These defaults may be changed by defining the following environment variables: +.IP R_RASTERFILE +If this variable is defined a Sun rasterfile will be generated, otherwise a +Postscript plotfile is generated. The string value of the variable is a +\fIprintf\fR style format string to be used to generate the filename of +the rasterfile. If multiple rasterfiles are to be generated, the format +string may contain a decimal integer field (e.g., "\fLframe.%d\fR") to be +replaced by the \fIfile number\fR of the current rasterfile. The first file +generated will be number zero, with the file number being incremented once +for every rasterfile produced. If Postscript plotfile output is desired, +the plotfile will be a uniquely named temporary file in \fB/tmp\fR. +.IP R_DISPOSE +The string value of this variable is a \fIprintf\fR style format string with +one string valued subfield to be replaced by the plotfile or rasterfile name, +to be used to generate the command used to dispose of the output file. +If this variable is not defined and the output file is a Postscript plotfile, +the default format string \fL"lpr -Plw -r -s %s"\fR will be used. +If the variable is not defined and the output file is a rasterfile, +no action is taken. It is the responsibility of the dispose command to +delete the output file. +.LP +It should only take several seconds to capture the screen and produce the +output rasterfile or queue the Postscript job to the printer. The screen +is flashed to indicated when the operation has completed. The Postscript +processing time may take up to several minutes (of laserwriter time) in the +worst case, i.e., a hardcopy of the full workstation screen. +.if t .sp 0.08i +.SS The Setup Panel +.LP +The setup panel is used to dynamically change terminal options while the +terminal is in use. In general, nearly any terminal option which can be +set on the command line when \fBgterm\fR is started can also be set via the +setup panel, and vice versa. The setup panel can also be used to reset +the terminal to the startup or "power on" state. +The setup panel may be called up at any time via the frame menu; it is normally +closed after the desired setup action has been performed. By default the setup +panel is located within the text window, but it may be moved anywhere else on +the workstation screen if desired. +.LP +There are two types of items in the setup panel: multiple choice options and +"push buttons". To see what the choices are in a multiple choice option, +position the mouse to the area where the current choice is displayed and +depress the right mouse button. At this point a selection may be made by +moving the mouse to the desired selection and releasing the mouse button. +Alternatively, the left mouse button may be used to cycle through the choices. +To perform the action indicated on a push button, place the mouse cursor on +the button and press the left mouse button. +.LP +The multiple choice options in the setup panel are the following: +.IP "\fBGraphics plane" +These options determine what the terminal does when graphics data and +control instructions are encountered in the input stream. +\fBDisable\fR means disable the graphics plane, causing the terminal to +output graphics control codes and data as printable characters +in the text window. +\fBEnable\fR means enable the graphics plane for normal mixed text and +graphics operation. +\fBDiscard Graphics Data\fR means discard all graphics data, effectively +disabling the graphics plane. +.IP "\fBOpen workstation action\fR" +These options determine the action taken by the terminal when graphics mode +is entered. Some visible action is generally desirable to render the graphics +window fully visible, and to indicate that a mode switch has occurred. +\fBNo action\fR means do nothing which visibly affects the workstation. +\fBShow graphics\fR means open the graphics window, e.g., if the graphics +window is to be closed (not displayed) when the terminal is in text mode. +\fBExpose graphics\fR means move the graphics window to the top of the stack +of open windows, displaying any portions of the graphics window which may have +been covered by other windows (such as the text window). +.IP "\\fBClose workstation action\\fR" +These options determine the action taken by the terminal when graphics mode +is exited, returning the terminal to text mode. +\fBNo action\fR means do nothing. +\fBBlank graphics\fR means close the graphics window, i.e., remove the window +from the screen. +\fBHide graphics\fR means move the graphics window to the bottom of the stack +of open windows, allowing any overlapping windows to cover the graphics window. +.IP "\\fBPause on close workstation\\fR" +This boolean option determines whether or not the terminal displays the +\fBpause panel\fR, waiting for a key to be typed, before exiting graphics +mode following a noninteractive graphics session (no cursor input). +.IP "\\fBRetain graphics frame\\fR" +This boolean option determines whether or not the contents of the graphics +window are \fIretained\fR. Graphics drawing will be somewhat faster if the +graphics plane is not retained, but almost any event which affects the region +of the screen occupied by the graphics window will cause the contents +of an unretained window to be lost. +.IP "\\fBClip graphics\\fR" +This boolean option determines whether or not graphics vectors are clipped +to the boundaries of the visible portions of the graphics window. Graphics +drawing will be somewhat faster if clipping is disabled, but +vectors may be drawn in nearby, unrelated windows, +especially if the graphics window is partially covered by other windows. +.IP "\\fBGraphics screen type\\fR" +This option determines whether the graphics plane is to be displayed in color +or monochrome on a color workstation. If \fBmono\fR is selected the foreground +and background colors specified when \fIsuntools\fR was started are used. +If \fBcolor\fR is specified graphics will be rendered in color, with the +colors used being specified by the \fB\-Wb\fR and \fB\-Wf\fR generic tool +arguments in \fIgioargs\fR. On a monochrome workstation the only option +displayed will be \fBmono only\fR, indicating that color is not available. +.IP "\\fBGraphics video\\fR" +This option specifies whether graphics are to be rendered in \fBnormal\fR or +\fBreverse\fR video. Specifying reverse video causes the foreground and +background colors of the graphics window to be reversed. +This option may not work on some monochrome workstations. +.IP "\fBGraphics font and screen sizes\fR" +This option is used to select at runtime the size of graphics window to be used. +The graphics window may be resized at any time, including while graphics is +being drawn or during a cursor read, but any displayed graphics should always +be redrawn following a window resize to ensure that the graph reflects the new +coordinate system. +The graphics window configurations currently available are listed below +in the form ``\fIpointsize\fR:[\fIwidth\fRx\fIheight\fR]'', +where \fIwidth\fR and \fIheight\fR are in pixels. The size of the full screen +is workstation dependent, the most common size currently being 1152x900. +The exact set of fonts and screen sizes may change in the future as new +fonts become available and workstations increase in resolution. +.if t .sp 0.05i +.ti +0.3i +10:[560x420] 12:[640x490] 14:[720x560] 16:[800x630] 18:[880x665] 24:fullscreen +.if t .sp 0.05i +All choices represent 35x80 windows with the standard landscape mode aspect +ratio. The size of the graphics window is the size in pixels of a character +of the fixed width font used, scaled by 35 vertically and by 80 horizontally. +Arbitrary sized windows may also be created by manually sizing the window +with the mouse, but this is bound to result in windows with a nonstandard +number of lines or columns of text, or a nonstandard aspect ratio. +.IP "\fBGIN mode terminators\fR" +Set the GIN (graphics or cursor mode input) terminator characters to the +indicated octal values. When a key is hit to terminate a cursor read, the +terminal transmits a 5 character cursor value sequence to the applications +program, following by one or two GIN mode terminator characters. +The required GIN mode terminator(s) will in general depend upon the +applications program being run. Some programs require no terminators, +others require a single CR (octal 015), and so on. +The default GIN mode terminator is a single CR. +.if t .sp 0.05i +To enter a new value, select the value box with the left mouse button, +rubout the old value, and type in the new value as a string, with zero, one, +or two octal values denoting the desired terminator characters, then hit +return to establish the new value. Entering a blank string disables both +terminators. +.LP +The following "push buttons" are also provided in the setup panel: +.RS +.IP \fBReset\fR 15 +Reset the terminal to the "power on" state, preserving the values of any +options set on the command line, but cancelling any options selected via +the setup panel. A \fBsetup reset\fR is indicated if the terminal does not +seem to be behaving correctly. Resetting the internal state of the terminal +has no effect on the operation of any applications program being run from +the terminal. +.IP \fBClear\fR +Clear the text window (the F9 function key performs the same function). +.IP \fBGclear\fR +Clear the graphics window, leaving the terminal in graphics mode +(the F8 function key performs the same function). +.IP "\fBShow graphics\fR" +Open (display) or close (undisplay) the graphics frame. The contents of the +graphics frame are not affected. +.IP \fBQuit\fR +Close the setup panel. +.RE +.LP +Closing and opening either the text or graphics frame has no effect on the +state of the terminal or on the applications program running within it, +even while a cursor read is in progress. +.if t .sp 0.08i +.SS Function Keys +.LP +The following function keys have special significance to \fIgterm\fR: +.RS +.IP F8 15 +In text mode, causes a switch to graphics mode. +When already in graphics mode, causes the graphics frame to be cleared. +.IP F9 +In graphics mode, causes a switch to text mode. +When already in text mode, causes the text frame to be cleared. +.RE +.LP +To momentarily view the graphics frame while in text mode, one can type F8 +followed by F9, without affecting the contents of either window. +Commands may be entered in either window, hence to direct the output of +a command to the graphics window, one could hit F8, execute the command, +and then hit F9 to return to the text window. The standard SunView L7 key, +used to close a window, is also detected by \fIgterm\fR, +hence closing the graphics +window with L7 while in graphics mode will automatically cause the terminal +to revert to text mode. +.LP +Manual control of the terminal mode is sometimes necessary when running +naive graphics programs in a \fIgterm\fR window. +When running a graphics program +which uses only standard 4012 instructions, it may be necessary to manually +put the terminal into graphics mode with the F8 function key before running the +program, or part of the program output may be "lost" (directed to the text +window and discarded). Similarly, naive programs will not return the terminal +to text mode after generating a plot, hence it will be necessary for the +user to hit the F9 key to return to text mode. +.LP +Additional function keys may be defined in the user \fB~/.ttyswrc\fR file. +For example, the function key definitions +.if t .sp 0.05i +.if n .sp +.RS +.nf +mapo R1 ^[[8;24;80t +mapo R2 ^[[8;34;80t +mapo R3 ^[[8;40;80t +.fi +.RE +.if t .sp 0.05i +.if n .sp +will program the R1, R2, and R3 function keys to set the size of the text +window to 24, 34, or 40 lines by 80 columns when the corresponding function +key is typed. These definitions are handy for rapidly resizing the text +window to one of the "standard" terminal sizes; this is especially useful +when executing programs remotely over the network, as most such programs +assume some standard size terminal screen. +.if t .sp 0.08i +.SS Mouse Buttons +.LP +The significance of the mouse buttons depends upon which window the mouse is +in, and upon whether or not the terminal is in GIN mode, i.e., in the process +of reading the graphics cursor. When the terminal is in text mode and the +mouse is in the text window, the mouse buttons are used only for the +\fBselection service\fR, as described in \fIshelltool\fR(1). +The functions of the mouse buttons while the mouse is in the graphics window +are outlined below. +.RS +.IP "Left button" 15 +Ignored except in GIN mode, when it may be aliased to a keyboard key and used +to terminate a cursor read. +.IP "Middle button" +Ignored except in GIN mode, when it may be aliased to a keyboard key and used +to terminate a cursor read. +.IP "Right button" +In GIN mode, may be aliased to a keyboard key and used to terminate a cursor +read. When not in GIN mode, causes the cursor crosshairs to be displayed +while the button is depressed. +.RE +.LP +The ability to \fBalias\fR mouse buttons to keyboard keys is a very important +one as it allows arbitrary graphics programs which are driven via an +interactive graphics cursor loop to be controlled completely from the mouse, +rather than having to position the mouse and then hit a key on the keyboard +to terminate each cursor read. For example, to alias \fIkey\fR to the left +mouse button, one would depress the control key and tap the left mouse button +twice, immediately after hitting \fIkey\fR to terminate a normal cursor read. +Thereafter, either \fIkey\fR or the left mouse button may be used equivalently +to terminate a cursor read. The alias remains in effect until the terminal is +\fIreset\fR or the alias is reassigned to a different key. +.if t .sp 0.08i +.SS The Terminal Emulator +.LP +The normal function of the terminal is to simultaneously listen for input +(program output) on the pseudoterminal file descriptor, while servicing +asynchronous keyboard and mouse events generated by the user. +The input data stream from the applications program consists of a mixture +of text and graphics data transmitted as an ASCII byte stream with no record +boundaries. Null bytes in the input data stream are ignored, and no programmed +delays are needed for proper terminal operation. As input data is received +asynchronously it is copied into a circular buffer and a synchronous event is +queued to call a routine which subsequently processes the input characters +onto the screen. If input data arrives faster than it can be processed onto +the screen \fB<ctrl/s>\fR is transmitted to the \fIpty\fR terminal driver, +followed by \fB<ctrl/q>\fR once the circular buffer empties. +Characters typed by the user are transmitted directly to the terminal driver, +which in normal operation will echo the characters back to the terminal as +ordinary data. +.LP +The initial state of the terminal is text mode. Transition to graphics mode +occurs when the GS character is encountered in the input data stream. +Transition back to text mode occurs when the CAN character is encountered in +the input stream. While text mode is in effect all input is passed on to the +TTY subwindow; while graphics mode is in effect all input is passed on to the +graphics subwindow. The behavior of the ANSI standard TTY subwindow is +documented elsewhere (e.g., \fIshelltool\fR(1), \fIcons\fR(4s), and Chapter 10 +of the \fISunView Programmer's Guide\fR) hence will not be discussed further +here. Likewise, the basic Tektronix 4012 protocol is a well known standard +and need not be documented in detail here. +.LP +The control codes and escape sequences recognized by the \fIgterm\fR graphics +window are summarized below. Sequences marked with a \(**\(** at the right +are nonstandard extensions, although all except the status line feature are +fairly common extensions. +.if t .sp 0.05i +.ta +0.5i +1.5i +3.5i +.nf + GS (035) \fBopen workstation\fR, start normal vector drawing sequence + CAN (030) \fBclose workstation\fR ** + FS (034) start pointmode vector + US (037) set alpha mode + CR (015) set alpha mode and execute carriage return + BEL (007) ring bell and/or flash screen +.if t .sp 0.05i + ESC CR set status line mode (ESC = 033) ** + ESC ENQ inquire graphics state and cursor position + ESC SUB initiate a cursor read (SUB = 032) + ESC FF clear screen, home alpha cursor (FF = 014) + ESC / f set cursor position to current drawing coordinates ** + ESC 0 set character size 0 + ESC 1 set character size 1 [not implemented] + ESC 2 set character size 2 [not implemented] + ESC 3 set character size 3 [not implemented] + ESC / 0 d set data level 0 (clear bits) ** + ESC / 1 d set data level 1 (set bits) ** + ESC / 2 d set data level 2 (toggle bits) ** + ESC ` set line style 0 (solid) + ESC a set line style 1 (dashed) + ESC b set line style 2 (dotted) + ESC c set line style 3 (dashdot) + ESC d set line style 4 (dash3dot) + ESC / 0 w set line width 0 (1 pixel) ** + ESC / 1 w set line width 1 (2 pixels) ** + ESC / 2 w set line width 2 (3 pixels) ** +.fi +.if t .sp 0.05i +.LP +Both text and vectors may be erased by setting the data level to 0 and +redrawing the objects to be erased. Erasing points which are common to more +than one object will cause gaps in other objects sharing the erased point. +.LP +Setting \fBstatus line\fR mode causes the region of the graphics frame +occupied by the status line to be saved in a memory pixrect, after which the +status line is cleared and the status line alpha cursor positioned to the +start of the line (the status line is a single 80 character line of text at +the bottom of the graphics window). While output is directed to the status +line, data characters are output in the status line as for a terminal. +BS and DEL behave as expected, allowing characters to be erased. +Lines longer than 80 characters are truncated at the right margin. +LF (newline) is treated the same as CR, causing the entire line to be erased, +and if multiple lines of text are rapidly written to the status line +they will scroll as on a one-line terminal. Status line mode is terminated +by any control character in the input data stream, e.g., GS, FS, CAN, ESC, +and so on. Note that terminating status line mode does not in itself erase +the status line, restoring the saved region of the graphics frame to the +screen; this is done by transmitting newline or CR to the terminal. +.if t .sp 0.08i +.SH SEE ALSO +suntools(1), shelltool(1), tektool(1), cmdtool(1), pty(4), cons(4s) +.br +\fISunView Programmer's Guide\fR, Chapter 10 \- TTY Subwindows +.br +\fIWindows and Window-Based Tools: Beginner's Guide\fR +.if t .sp 0.08i +.SH FILES +.LP +.nf +~/.ttyswrc +/usr/bin/suntools +/usr/lib/rootmenu +/usr/lib/fonts/fixedwidthfonts/* +$iraf/local/sun/gterm.c +.fi +.if t .sp 0.08i +.SH BUGS +.IP (1) +\fIgterm\fR is a complex program operating in an extremely dynamic environment. +The program has been thoroughly tested and is quite reliable, but it is +nonetheless possible for the program to get into peculiar states where it +does not behave as expected. Should this happen, a \fIsetup reset\fR should +restore the terminal to a known state. +.IP (2) +If more than 256 characters are input to a terminal emulator subwindow without +an intervening newline, the terminal emulator may hang (to demonstrate this, +hold any key down until the autorepeat generates sufficient characters). +If this occurs, display the tty subwindow menu and select the \fBflush input\fR +item to correct the problem. +.IP (3) +When using a terminal emulator to execute a program on a remote node via a +network interface (rlogin, telnet, etc.), and the remote program continuously +outputs a large amount of data, the terminal will occasionally hang up for +several seconds, after which normal output will resume. Typing any character +will cause output to resume immediately, but the character will later be +delivered to the remote program as normal input hence should be selected with +care (\fB<ctrl/q>\fR is always harmless). The origin of this bug is not clear, +but since all terminal emulators are equally affected, it must be something +in the terminal driver, or elsewhere in the SunOS kernel. +.IP (4) +The hardcopy functions assume a 1 or 8 bit frame buffer and will not work +properly on a Sun-3/110, 3/60, etc., unless the \fB\-8bit_color_only\fR option +is specified to \fIsuntools\fR [\fIfixed in Gterm V1.2]\fR. +.IP (5) +Reverse video does not work on a monochrome workstation as there is no +colortable and no way to exchange the foreground and background colortable +entries; try the \fB\-i\fR option to \fIsuntools\fR instead. +.IP (6) +\fIgterm\fR modifies the keyboard translation table entries for the arrow keys +while a cursor read is in progress, restoring the translation table entries +when done (this is necessary to allow the arrow keys to be used to terminate +cursor reads). If something should happen to \fIgterm\fR while it is waiting +for cursor input, it is possible that the arrow key translation table entries +may not be restored. If this should happen, executing \fBsetkeys reset\fR will +fix things. Note also that changes to the keyboard translation tables are +global, i.e., all windows are affected, hence while a cursor read is in +progress in a \figterm\fR window, the arrow keys may not be usable with a +program running in a different window. +.IP (7) +When plotting with clipping disabled there are cases where it is possible for +\fIgterm\fR to coredump with a segmentation violation, killing any interactive +subprocesses running within the terminal. +.SH AUTHOR +Doug Tody, National Optical Astronomy Observatories (NOAO), IRAF project. diff --git a/unix/sun/gtermio.c b/unix/sun/gtermio.c new file mode 100644 index 00000000..d0348de2 --- /dev/null +++ b/unix/sun/gtermio.c @@ -0,0 +1,1224 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <suntool/sunview.h> +#include <pixrect/pr_line.h> +#include <sys/ioctl.h> +#include <ctype.h> +#include <stdio.h> +#include "gterm.h" + +/* + * GTERMIO -- Graphics terminal i/o. This is the low level code which + * filters graphics output out of the pseudoterminal output stream and + * then processes the graphics instructions, drawing into the graphics + * pixwin. Graphics output from the pty is written into a circular + * buffer by a low level routine called when data is read from the pty + * by the ttysw code. A differed routine is called back by the notifier + * to process the data, writing graphics into the gio pixwin. The graphics + * data language implemented is tektronix standard plus extensions. + */ + +extern int clip_graphics; +extern int cursor_show; +extern int gio_canvas; +extern FILE *gt_logfp; +int gio_graphicsenabled = 0; /* switch text/graphics output */ +int gio_enabled = 1; /* enable graphics window */ + +/* Size limiting definitions. */ +#define SZ_GBUF 8192 /* max buffered graphics data */ +#define GB_MINSPACE 2048 /* XOFF when this much left */ +#define GB_BIGSPACE 3072 /* XON when this much available */ +#define MAX_PLPTS 4096 /* max points in a polyline */ +#define SZ_TXBUF 256 /* max chars in a polytext */ +#define MAX_TEXTCHARS 80 /* max chars in text line */ +#define SL_XOFFSET 0 /* x offset to status line */ +#define SL_YOFFSET 5 /* y offset to status line */ +#define MAX_QUOTA 512 /* limit for one proc. loop */ +#define WSOPEN_DELAY 100 /* delay at openws (msec) */ +#define WSCLOSE_DELAY 0 /* delay at closews (msec) */ +#define LOG_SYNCTIME 15 /* sync interval for logfile */ + +/* Magic numbers. */ +#define SET_BITS 0 /* draw vectors|points */ +#define CLEAR_BITS 1 /* erase vectors|points */ +#define TOGGLE_BITS 2 /* toggle data bits */ +#define COMMAND_MODE 0 /* initial state */ +#define ALPHA_MODE 1 /* tek-alpha character drawing */ +#define TEXT_MODE 2 /* output to status line */ +#define VECTOR_MODE 3 /* draw vectors or points */ +#define CURSOR_MODE 4 /* read crosshair cursor posn */ +#define BREAK_LINE (-2) /* special automargin code */ + +/* ASCII codes. */ +#define ENQ '\005' +#define BEL '\007' +#define CR '\015' +#define CAN '\030' +#define SUB '\032' +#define ESC '\033' +#define FS '\034' +#define GS '\035' +#define RS '\036' +#define US '\037' + +/* Pseudoterminal i/o. + */ +static int pty_fd; /* fd of pseudoterminal */ +static int pty_stop = 0; /* set when XOFF is set on pty */ + +/* The graphics data buffer, a circular buffer. + */ +static char g_buf[SZ_GBUF]; /* circular buffer */ +static char *g_top= &g_buf[SZ_GBUF];/* end of buffer + 1 */ +static char *g_ip = g_buf; /* input pointer */ +static char *g_op = g_buf; /* output pointer */ + +#define g_getc(c)\ + (g_ip==g_op ? -1 : ((c) = *g_ip++, g_ip >= g_top ? *(g_ip=g_buf):0)) +#define g_putc(c)\ + (*g_op++ = (c), ((g_op >= g_top) ? g_op = g_buf : g_op)) +#define g_ungetc(c)\ + (g_ip = ((g_ip==g_buf) ? g_top-1 : g_ip-1)) +#define g_spaceleft\ + (g_ip <= g_op ? (g_top - g_op + g_ip - g_buf) : (g_ip - g_op)) +#define g_havedata (g_ip != g_op) +#define g_mark(ip) ((ip)=g_ip) +#define g_reset(ip) (g_ip=(ip)) +#define g_equal(ip) ((ip)==g_ip) + +/* Polyline (polymarker) output-point buffer. + */ +static char pl_text[MAX_PLPTS]; /* encoded [x,y] coord data */ +static struct pr_pos pl_p[MAX_PLPTS]; /* polyline storage */ +static int pl_npts = 0; /* npoints in polyline */ +static int pl_op = 0; /* which char in coord pair */ +static int pl_linestyle = 0; /* dashline drawing style */ +static int pl_pointmode = 0; /* point or line mode */ + +static int ohiy=0; oloy=0; /* encoded current position */ +static int ohix=0; olox=0; + +static Pr_brush brush = { 1 }; +#define pl_linewidth brush.width /* vector drawing linewidth */ + +/* Graphics text variables. + */ +static struct fonttab *alpha_font; /* alpha mode font */ +static struct fonttab *text_font; /* text mode font */ +static char tx_buf[SZ_TXBUF+1]; /* polytext text buffer */ +static int tx_len = 0; /* nchars in buffer */ +static int tx_maxlines; /* nlines of text on a screen */ +static int tx_maxcols; /* ncols of text on a screen */ +static int tx_charheight; /* height of a char in pixels */ +static int tx_charwidth; /* width of a char in pixels */ +static int tx_charbase; /* topline to baseline distance */ +static int tx_leftmargin; /* where columns start */ +static int sl_x, sl_y; /* current pos. in status line */ +static int sl_xoff, sl_yoff; /* x,y offset of status line */ +static int sl_cwidth; /* status line char width */ +static int sl_cheight; /* status line char height */ +static int sl_cbase; /* topline to baseline distance */ +static int sl_width; /* status line rect width */ +static int sl_height; /* status line rect height */ +static int sl_rect_saved = 0; /* set after sl rect is saved */ +static struct pixrect *sl_pr=NULL; /* saved status line pixrect */ +static struct fonttab *chcur_font; /* character cursor font */ +static int chcur_x; /* character cursor xpos */ +static int chcur_y; /* character cursor ypos */ +static int chcur_on = 0; /* character cursor displayed? */ +static int chcur_skip = 0; /* used to skip cursor updates */ + +/* Miscellaneous variables. + */ +static struct pixwin *pw; /* graphics pixwin */ +static struct rect pw_r; /* full rect of the pixwin */ +static int cur_x, cur_y; /* current x,y position */ +static int win_xres, win_yres; /* size of graphics pixwin */ +static int tek_xres; /* X resolution of input data */ +static int tek_yres; /* Y resolution of input data */ +static int trailer1 = '\r'; /* trailer code, cursor value */ +static int trailer2 = -1; /* second trailer code (opt) */ +static int gio_mode=COMMAND_MODE; /* graphics drawing mode */ +static int gio_datalevel=SET_BITS; /* set, clear, or toggle bits */ +static int workstation_open = 0; /* have issued open workstation */ +static int wait_cursor = 0; /* waiting for cursor input */ +static int gio_delay = 0; /* programmed delay in progress */ + +int ev_ptyoutput(); +static Pr_texture *pl_texture(); +static Notify_value ev_gioprocessdata(); + +/* Macros to convert between tektronix and window coordinates. */ +#define X_TEK2WIN(x) ( ((x) * win_xres + tek_xres/2) / tek_xres) +#define Y_TEK2WIN(y) (win_yres - (((y) * win_yres + tek_yres/2) / tek_yres)) +#define X_WIN2TEK(x) ((( (x)) * tek_xres + win_xres/2) / win_xres) +#define Y_WIN2TEK(y) (((win_yres - (y)) * tek_yres + win_yres/2) / win_yres) + + +/* GIO_SETUP -- Called by the high level Gterm window management code to + * give the gtermio code the file descriptor of the pty and the pixwin of + * the graphics frame. + */ +gio_setup (fd, gio_pw) +int fd; /* fd of pty */ +struct pixwin *gio_pw; /* graphics pixwin */ +{ + pty_fd = fd; + pw = gio_pw; + + notify_read_post_monitor_fcn (pty_fd, ev_ptyoutput); + notify_set_event_func (ev_gioprocessdata, + ev_gioprocessdata, NOTIFY_SAFE); +} + + +/* GIO_HARDRESET -- Reset everything, including cancelling any cursor read + * that may be in progress. + */ +gio_hardreset (mc_xres, mc_yres, a_font, t_font) +int mc_xres, mc_yres; /* virtual x,y resolution */ +struct fonttab *a_font; /* alpha mode font */ +struct fonttab *t_font; /* text mode font */ +{ + gio_mode = COMMAND_MODE; + gio_graphicsenabled = 0; + workstation_open = 0; + wait_cursor = 0; + gio_delay = 0; + pty_stop = 0; + + ioctl (pty_fd, TIOCSTART, NULL); + gio_reset (mc_xres, mc_yres, a_font, t_font); +} + + +/* GIO_RESET -- Reset the state of the gtermio code. Should be called + * whenever any important data structures change, e.g., if the graphics + * frame is resized. + */ +gio_reset (mc_xres, mc_yres, a_font, t_font) +int mc_xres, mc_yres; /* virtual x,y resolution */ +struct fonttab *a_font; /* alpha mode font */ +struct fonttab *t_font; /* text mode font */ +{ + erase_cursor(); + chcur_skip = 0; + + tek_xres = mc_xres; + tek_yres = mc_yres; + alpha_font = a_font; + text_font = t_font; + + pw_get_region_rect (pw, &pw_r); + win_xres = pw_r.r_width; + win_yres = pw_r.r_height; + + tx_leftmargin = 0; + tx_charwidth = alpha_font->ch_xsize; + tx_charheight = alpha_font->ch_ysize; + tx_charbase = -alpha_font->pixfont->pf_char['0'].pc_home.y; + tx_maxlines = win_yres / tx_charheight; + tx_maxcols = win_yres / tx_charwidth; + tx_len = 0; + + sl_cwidth = text_font->ch_xsize; + sl_cheight = text_font->ch_ysize; + sl_cbase = -text_font->pixfont->pf_char['0'].pc_home.y; + sl_xoff = SL_XOFFSET; + sl_yoff = win_yres - SL_YOFFSET; + sl_x = sl_xoff; + sl_y = sl_yoff; + sl_width = win_xres - sl_xoff; + sl_height = sl_cheight; + + if (sl_pr != NULL) + pr_destroy (sl_pr); + sl_pr = mem_create (sl_width, sl_height, 1); + sl_rect_saved = 0; + + g_top = &g_buf[SZ_GBUF]; + g_ip = g_op = g_buf; + pl_npts = 0; + pl_op = 0; + pl_linestyle = 0; + pl_linewidth = 1; + pl_pointmode = 0; + ohiy = 0; oloy = 0; + ohix = 0; olox = 0; + + cur_x = tx_leftmargin; + cur_y = tx_charbase; +} + + +/* GIO_ENABLE -- Enable or disable the graphics window. If graphics is + * disabled, all i/o is directed to the text window. + */ +gio_enable (onoff) +int onoff; +{ + if ((gio_enabled = onoff) == GRAPHICS_OFF) + gio_graphicsenabled = 0; +} + + +/* GIO_SETGINMODETERM -- Set the GIN mode (cursor read) trailer codes, + * expressed as octal constants in the input string argument. + */ +gio_setginmodeterm (str) +char *str; +{ + register char *ip; + register int n; + + trailer1 = trailer2 = -1; + + for (ip=str; isspace(*ip); ip++) + ; + if (isdigit(*ip)) { + for (n=0; isdigit(*ip); ip++) + n = n * 8 + *ip - '0'; + trailer1 = n; + } + + while (*ip && isspace(*ip)) + ip++; + if (isdigit(*ip)) { + for (n=0; isdigit(*ip); ip++) + n = n * 8 + *ip - '0'; + trailer2 = n; + } +} + + +/* EV_PTYOUTPUT -- Process pty output packets. Output directed to the + * terminal (/dev/tty) by the applications program appears as read-pending + * events on the pty seen by the Gterm program. We let the TTY code monitor + * the pty and respond to read-pending events. The low level read primitive + * (notify_read) ultimately called to service a read request by TTY reads + * the data and then calls us to process the data packet. We extract any + * graphics output from the packet and append it to the gio buffer. If data + * is added to the gio buffer a gio-data-pending event is queued so that + * the graphics drawing code will be called to process the new data. The + * remaining data, or a null length packet if the packet contained only + * graphics data, is returned to TTY, completing the read. Sometime later + * the graphics drawing code will be called to process the data. + */ +ev_ptyoutput (ttybuf, nchars) +char *ttybuf; /* raw data on input, tty data on output */ +int nchars; /* nchars of raw data */ +{ + register char *itop = ttybuf + nchars; + register char *op, *ip = ttybuf, ch; + static unsigned long oldtime = 0; + + /* Copy to logfile if logging is enabled. */ + if (gt_logfp) { + fwrite (ttybuf, nchars, 1, gt_logfp); + if (time(0) - oldtime > LOG_SYNCTIME) { + /* Sync the logfile output every so often. */ + fflush (gt_logfp); + oldtime = time(0); + } + } + + if (gio_enabled == GRAPHICS_OFF || nchars <= 0) + return (nchars); + + /* If in text mode, make a quick scan for the GS character and return + * the entire data packet if GS is not seen. + */ + if (!gio_graphicsenabled) { + while (ip < itop && *ip != GS) + ip++; + if (ip >= itop) + return (nchars); + else { + gio_graphicsenabled++; + op = ip; + } + } else + op = ttybuf; + + /* Process rest of data in graphics mode. IP is pointing at the + * first char of graphics data, ITOP at the top of the buffer, + * and OP at the next tty output char. Filter out any NULs in + * the process of copying the data. + */ + while (ip < itop) + if (gio_graphicsenabled) { + while (ip < itop) + if ((ch = *ip++) == CAN) { + g_putc (ch); + gio_graphicsenabled = 0; + break; + } else if (ch) + g_putc (ch); + } else { + while (ip < itop) + if ((ch = *ip++) == GS) { + g_putc (ch); + gio_graphicsenabled = 1; + break; + } else if (ch) + *op++ = ch; + } + + /* If the gio buffer has reached the high-water mark and XOFF is + * not currently set, send XOFF to the terminal driver. + */ + if (g_spaceleft < GB_MINSPACE && !pty_stop) { + ioctl (pty_fd, TIOCSTOP, NULL); + pty_stop++; + } + + /* Post an event with the notifier to call the graphics drawing code + * back to process the new data. + */ + if (!gio_delay) + notify_post_event (ev_gioprocessdata, NULL, NOTIFY_SAFE); + + return (op - ttybuf); +} + + +/* EV_GIOPROCESSDATA -- Called to process graphics instructions and data from + * the gio buffer. This is the routine which actually draws lines and text + * in the graphics frame. May be called repeatedly to process any amount of + * data at a time. If there is a great amount of data to be processed the + * routine should return occasionally to allow the other GTERM event handlers + * to run (operation is not fully asynchronous). + * + * Graphics data is processed as a stream with no record boundaries, so that + * operation is not dependent on how data is buffered through the system. + * The graphics frame is a state machine which is by definition always in a + * legal state; garbage input causes garbage output, just like a real terminal. + * The states are as follows: + * + * COMMAND_MODE This is the initial state. Characters are accumulated + * until a known state is recognized. Receipt of ESC + * always causes command mode to be entered, since + * additional characters are needed to define the next + * instruction. + * + * ALPHA_MODE Characters are drawn in the graphics frame at the + * "current" position (normally set beforehand with a + * GS/US vector move), using the alpha mode font. + * Receipt of any control code causes alpha mode to be + * exited. + * + * TEXT_MODE Text mode is a special mode used to write transient + * text in the status line, using the text mode font. + * Lines of text are accumulated and displayed on the + * status line in reverse video; successive lines of text + * overwrite one another. The status line is cleared + * when text mode is entered, even if no text is drawn. + * Text mode is terminated by receipt of GS or CAN. + * + * VECTOR_MODE Vector mode refers to both polyline and polypoint + * vector sequences. The vertices of the points are + * accumulated in a buffer and displayed when the buffer + * fills or when vector mode is terminated. Vector + * mode is terminated by receipt of any control code; + * the tektronix coordinate encoding maps all possible + * coordinates into the printable ascii codes. + * + * CURSOR_MODE The crosshair cursor is turned on, signifying to the + * user that the system is waiting on a cursor read. + * Output processing ceases until the user types a key + * or presses a mouse button to trigger the cursor read. + * The cursor value is then encoded and transmitted back + * to the pty, and output processing resumes. + * + * Clearing the screen causes the mode to be reset to command mode, and all + * other drawing parameters to be set to their default values, e.g., data level + * on, solid line type, and so on. + */ +static Notify_value +ev_gioprocessdata() +{ + register int quota, ch; + char *save_ip, *ip_start; + int delay = 0; + + pw_lock (pw, &pw_r); + g_mark (ip_start); + + /* Process data. + */ + for (quota=MAX_QUOTA; --quota >= 0 && g_getc(ch) >= 0; ) { + if (ch == 0 || gio_enabled == GRAPHICS_DISCARD) + continue; +again: + switch (gio_mode) { + case COMMAND_MODE: + switch (ch) { + case GS: + case FS: + gio_mode = VECTOR_MODE; + pl_npts = 0; + pl_op = 0; + pl_pointmode = (ch == FS); + chcur_skip = -1; + if (cursor_show) + gio_setcursor (CURSOR_OFF, 0); + + /* Only execute an open workstation if we have not already + * done so and if the next command is something other than + * close workstation, i.e., no-op sequences GS-CAN are + * filtered out, since they would only cause a pointless + * switch to the graphics frame and back without drawing. + */ + if (ch == GS && !workstation_open) + if (g_getc(ch) < 0) { + g_ungetc (GS); + gio_mode = COMMAND_MODE; + goto exit; + } else if (ch != CAN) { + gio_open_workstation(); + workstation_open = 1; + delay = WSOPEN_DELAY; + g_ungetc (ch); + goto exit; + } + break; + + case US: + case CR: + gio_mode = ALPHA_MODE; + tx_len = 0; + if (ch == CR) + goto again; + break; + + case CAN: + if (workstation_open) { + pw_unlock (pw); + gio_close_workstation(); + workstation_open = 0; + delay = WSCLOSE_DELAY; + } + gio_mode = COMMAND_MODE; + goto exit; + + case ESC: + g_ungetc (ch); + g_mark (save_ip); + erase_cursor(); + if ((gio_mode = gio_escape()) == -1) { + gio_mode = COMMAND_MODE; + g_reset (save_ip); + goto exit; + } else if (gio_mode == CURSOR_MODE) + goto again; + break; + + case BEL: + window_bell (gio_canvas); + break; + + default: + ; /* ignore unknown control chars */ + } + break; + + case ALPHA_MODE: + /* Tek alpha mode is used to write text to random positions on + * the screen, or to write lines of text to the gio frame in + * "storage scope" mode, where the left and right columns are + * alternately written into with an inclusive-or rop. + */ + if (ch >= 040) { + tx_buf[tx_len++] = ch; + } else if (ch == '\t') { + tx_buf[tx_len++] = 040; + if (tx_leftmargin == 0) + while ((tx_len + (cur_x / tx_charwidth)) % 8 != 0) + tx_buf[tx_len++] = 040; + } else if (ch == '\010' || ch == '\177') { + if (tx_len > 0) + tx_len--; + else if (cur_x > tx_leftmargin) + cur_x -= tx_charwidth; + } else { +flush_alpha: if (tx_len > 0) { + tx_buf[tx_len] = '\0'; + erase_cursor(); + pw_text (pw, cur_x, cur_y, gio_rop(), + alpha_font->pixfont, tx_buf); + } + + cur_x += tx_len * tx_charwidth; + tx_len = 0; + + if (ch == '\n' || ch == BREAK_LINE) { + cur_y += tx_charheight; + if (cur_y > win_yres) { + if (tx_leftmargin == 0) + tx_leftmargin = win_xres / 2; + else + tx_leftmargin = 0; + cur_y = tx_charbase; + if (cur_x < tx_leftmargin) + cur_x = tx_leftmargin; + } + if (ch == BREAK_LINE) + cur_x = tx_leftmargin; + } else if (ch == '\r') { + cur_x = tx_leftmargin; + } else if (ch != 0) { + gio_mode = COMMAND_MODE; + goto again; + } + } + + /* Break long lines at the right margin. */ + if (cur_x + (tx_len * tx_charwidth) >= win_xres) { + ch = BREAK_LINE; + goto flush_alpha; + } + + break; + + case TEXT_MODE: + if (ch >= 040) + tx_buf[tx_len++] = ch; + else if (ch == '\t') + tx_buf[tx_len++] = 040; + else if (ch == '\010' || ch == '\177') { + if (tx_len > 0) { + --tx_len; + sl_x -= sl_cwidth; + erase_cursor(); + pw_text (pw, sl_x, sl_y, + PIX_SRC, text_font->pixfont, " "); + } + } else { + if (tx_len > 0) { + tx_buf[tx_len] = '\0'; + erase_cursor(); + pw_text (pw, sl_x, sl_y, + PIX_NOT(PIX_SRC), text_font->pixfont, tx_buf); + } + + sl_x += tx_len * sl_cwidth; + if (sl_x > win_xres - sl_cwidth) + sl_x = win_xres - sl_cwidth; + tx_len = 0; + + if (ch == '\r' || ch == '\n') { + sl_x = sl_xoff; + sl_restore_rect(); + } else if (ch != 0) { + gio_mode = COMMAND_MODE; + goto again; + } + } + + /* Truncate long lines. */ + if (sl_x / sl_cwidth + tx_len >= MAX_TEXTCHARS) + if (tx_len > 0) + --tx_len; + else + sl_x -= sl_cwidth; + break; + + case VECTOR_MODE: + /* Following receipt of GS, accumulate encoded coordinate data + * until the buffer fills or a control code is received, then + * decode the encoded data to reconstruct the original data + * vector, and draw the vector. + */ + if (ch >= 040) + pl_text[pl_op++] = ch; + if (ch < 040 || pl_op >= MAX_PLPTS) + pl_decodepts(); + + if (ch < 040 || pl_npts >= MAX_PLPTS) { + if (pl_pointmode && pl_npts >= 1) { + pw_polypoint (pw, 0, 0, pl_npts, pl_p, + PIX_COLOR(1) | gio_rop()); + } else if (pl_npts >= 2) { + /* Must use clipping if dashed line. */ + pw_polyline (pw, 0, 0, pl_npts, pl_p, + POLY_DONTCLOSE, &brush, pl_texture(pl_linestyle), + (PIX_COLOR(1) | gio_rop()) & + ~(pl_linestyle ? PIX_DONTCLIP : 0)); + } + + if (pl_npts > 0) { + cur_x = pl_p[pl_npts-1].x; + cur_y = pl_p[pl_npts-1].y; + pl_npts = 0; + } + + if (ch < 040) { + gio_mode = COMMAND_MODE; + pl_op = 0; + goto again; + } + } + + break; + + case CURSOR_MODE: + if (wait_cursor++) { + g_ungetc (ch); + gio_mode = COMMAND_MODE; + } else + gio_readcursor(); + break; + } + } + +exit: + /* Flush any buffered text before exiting, as applications will assume + * that text appears on the screen as soon as chars are written to the + * terminal (any buffering must be hidden). + */ + if (tx_len > 0) { + ch = 0; + goto again; + } + + update_cursor(); + pw_unlock (pw); + + /* If XOFF is set and the buffer has emptied sufficiently, + * send XON to the terminal driver to accept more data. + */ + if (pty_stop && g_spaceleft > GB_BIGSPACE) { + ioctl (pty_fd, TIOCSTART, NULL); + pty_stop = 0; + } + + /* If there is still data in the buffer (other than a partially + * formed escape sequence) post another callback event before exiting + * to allow other event handlers to run. + */ + if (delay) + gio_pause (delay); + else if (g_havedata && !g_equal(ip_start) && ch != ESC && !wait_cursor) + notify_post_event (ev_gioprocessdata, NULL, NOTIFY_SAFE); + + return (NOTIFY_DONE); +} + + +/* PL_DECODEPTS -- Convert a sequence of textronix encoded polyline vertices + * into a simple array of [x,y] coordinate pairs. Each coordinate pair is + * encoded as a sequence of from 1 to 4 bytes, with bytes being optionally + * eliminated which do not change from one coordinate pair to the next. The + * possible coordinate pair encodings are as follows: + * + * HIY LOY HIX LOX + * 01xxxxx 11xxxxx 01xxxxx 10xxxxx + * 040 140 040 100 + * + * HIY LOX + * HIY LOY LOX + * HIY LOY HIX LOX + * LOY HIX LOX + * LOY LOX + * LOX + * + * In words, bytes which do not change need not be sent, except for the low-x + * byte (LOX). If the high-x byte changes, then the low-x byte must also be + * sent. The current position, stored as the 4 byte encoding, is cleared to + * zero when the screen is cleared. + */ +static +pl_decodepts() +{ + register char *ip, *itop; + int hiy, loy, hix, lox, type, data, nb; + char *ip_save; + + for (ip_save=ip=pl_text, itop = &pl_text[pl_op]; ip < itop; ) { + hiy = ohiy; loy = oloy; + hix = ohix; lox = olox; + + for (nb=0; nb < 99 && ip < itop; nb++) { + type = (*ip & 0140); + data = (*ip++ & 037); + + switch (type) { + case 040: /* HIY, HIX */ + if (nb == 0) + hiy = data; + else + hix = data; + break; + case 0140: /* LOY */ + loy = data; + break; + + case 0100: + /* Receipt of LOX marks the end of the variable length + * sequence of bytes required to form the next [x,y]. + */ + lox = data; + pl_p[pl_npts].x = X_TEK2WIN ((hix << 5) + lox); + pl_p[pl_npts].y = Y_TEK2WIN ((hiy << 5) + loy); + + /* Update current position. */ + ohiy = hiy; oloy = loy; + ohix = hix; olox = lox; + + ip_save = ip; + pl_npts++; + nb = 99; /* EXIT */ + break; + } + } + } + + /* If there is any data left over (too few bytes to form a coordinate + * pair) move these to the start of the buffer. + */ + for (pl_op=0, ip=ip_save; ip < itop; ) + pl_text[pl_op++] = *ip++; +} + + +/* GIO_PAUSE -- Suspend output for the indicated number of milliseconds, to + * allow other event processing to catch up. When the specified interval has + * passed an ev_gioprocessdata event is posted to resume output processing. + */ +gio_pause (msec) +int msec; +{ + static Notify_value ev_restart(); + static struct itimerval itimer_delay; + + gio_delay = msec; + + itimer_delay.it_interval.tv_usec = 0; + itimer_delay.it_interval.tv_sec = 0; + + itimer_delay.it_value.tv_usec = (msec % 1000) * 1000; + itimer_delay.it_value.tv_sec = (msec / 1000); + + notify_set_itimer_func (&itimer_delay, ev_restart, ITIMER_REAL, + &itimer_delay, NULL); +} + + +/* EV_RESTART -- Called when the specified interval has passed to restart + * output processing. + */ +static Notify_value +ev_restart() +{ + gio_delay = 0; + notify_post_event (ev_gioprocessdata, NULL, NOTIFY_SAFE); + + return (NOTIFY_DONE); +} + + +/* GIO_RETCURSOR -- Encode and return a cursor value to the pty (and thence + * to the program which initiated the cursor read). Clear the cursor read + * pending flag so that output processing can resume, and post an event to + * restart the output processing routine. + */ +gio_retcursor (key, x, y) +int key; /* key (or whatever) typed to trigger read */ +int x, y; /* pixwin coords of event */ +{ + register int mc_x, mc_y; + char curval[7]; + int len; + + /* Ignore cursor events unless requested via program control. + */ + if (!wait_cursor) + return (-1); + + mc_x = X_WIN2TEK (x); + mc_y = Y_WIN2TEK (y); + + curval[0] = key; + curval[1] = ((mc_x >> 5) & 037) | 040; + curval[2] = ((mc_x ) & 037) | 040; + curval[3] = ((mc_y >> 5) & 037) | 040; + curval[4] = ((mc_y ) & 037) | 040; + curval[5] = trailer1; + curval[6] = trailer2; + + len = 5; + if (trailer1 >= 0) len++; + if (trailer2 >= 0) len++; + write (pty_fd, curval, len); + + wait_cursor = 0; + gio_mode = COMMAND_MODE; + chcur_skip = -1; + + if (!gio_delay) + notify_post_event (ev_gioprocessdata, NULL, NOTIFY_SAFE); +} + + +/* GIO_RETENQ -- Respond to the ESC ENQ request. + */ +gio_retenq() +{ + register int mc_x, mc_y; + char curval[7]; + int len; + + /* Graphics status word. */ + curval[0] = (061 | ((gio_mode == ALPHA_MODE) << 2) + | ((tx_leftmargin != 0) << 1)); + + /* Alpha cursor position. */ + mc_x = X_WIN2TEK (cur_x); + mc_y = Y_WIN2TEK (cur_y); + + curval[1] = ((mc_x >> 5) & 037) | 040; + curval[2] = ((mc_x ) & 037) | 040; + curval[3] = ((mc_y >> 5) & 037) | 040; + curval[4] = ((mc_y ) & 037) | 040; + curval[5] = trailer1; + curval[6] = trailer2; + + len = 5; + if (trailer1 >= 0) len++; + if (trailer2 >= 0) len++; + write (pty_fd, curval, len); +} + + +/* Definitions and data structures for a fast table driven fixed pattern + * escape sequence recognizer. Given character I of the sequence there will + * be N candidate sequences that have matched the first I-1 chars. Examine + * each to produce the next list of candidate sequences. Continue until either + * a sequence is matched or there are no more candidates. Variable length + * sequences such as "ESC[Pl;PcH" are handled as a special case: the general + * form of these is ESC '[' <digits> [';' <digits>...] LET. + */ +#define MAX_CANDIDATES 32 /* max candidate escseq */ +#define MAX_FIELDS 6 /* max fields in an escseq */ + +struct _esc { + char e_tag; /* integer code for escseq */ + char e_seq[MAX_FIELDS+1]; /* the sequence itself */ +}; + +static struct _esc *e_cand1[MAX_CANDIDATES]; /* 1st candidates array */ +static struct _esc *e_cand2[MAX_CANDIDATES]; /* 2nd candidates array */ +static struct _esc **e_pcand, **e_acand; /* candidates arrays */ +static int e_npcand, e_nacand; /* number of candidates */ +static int e_charno; /* char being examined */ + +static struct _esc e_table[] = { +#include "gterm.esc" /* Gterm escape sequence table */ + { 0, 0,0,0,0,0,0,0 } +}; + + +/* GIO_ESCAPE -- Recognize and process graphics escape sequences, i.e., + * all multicharacter command codes beginning with ESC. The simple single + * character command codes are handled directly by the data processing code. + * The escapes have no well defined pattern to them, hence we must simply + * consume characters until a legal escape sequence is recognized or the + * sequence is found to not match any known sequence. It is possible that + * all of the characters forming a sequence will not yet have been deposited + * in the input buffer, in which case we return -1, indicating to our caller + * that we should be called back later to rescan the same input, when more + * data becomes available. Otherwise, we take whatever action is implied + * for the escape sequence and return the new mode to the interpreter code. + * If an unrecognized escape sequence is encountered it is discarded and we + * return in alpha mode so that subsequent input appears as garbage on the + * screen. + */ +gio_escape() +{ + register struct _esc *esc; + register int ch, i, j; + struct _esc **e_temp; + int tag; + + /* Discard the ESC and get the first char. */ + g_getc (ch); + if (g_getc (ch) < 0) + return (-1); + + /* Build the initial list of candidates. This is the most expensive + * step, since all sequences must be examined. + */ + for (esc=e_table, e_pcand=e_cand1, e_npcand=0; esc->e_tag; esc++) + if (ch == esc->e_seq[0]) { + if (esc->e_seq[1] == 0) { + tag = esc->e_tag; + goto action; + } + e_pcand[e_npcand++] = esc; + } + + /* If there were no candidates, we are done. */ + if (e_npcand == 0) { + g_ungetc (ch); + return (ALPHA_MODE); + } + + /* Examine successive characters from the input, building a new, + * shorter candidate list on each iteration. This should converge + * very rapidly one way or the other. + */ + for (j=1, e_acand=e_cand2; j < MAX_FIELDS && e_npcand > 0; j++) { + if (g_getc(ch) < 0) + return (-1); + + /* Examine the next character of each sequence in the list of + * candidate sequences. If we have a complete match, we are + * done, else if we have a single character match add the seq + * to the new candidates list. + */ + e_nacand = 0; + for (i=0; i < e_npcand; i++) { + esc = e_pcand[i]; + if (ch == esc->e_seq[j]) { + if (esc->e_seq[j+1] == 0) { + tag = esc->e_tag; + goto action; + } + e_acand[e_nacand++] = esc; + } + } + + e_temp = e_pcand; e_pcand = e_acand; e_acand = e_temp; + e_npcand = e_nacand; + } + + /* If the escape sequence was recognized the above code should have + * vectored off to the action marker below. If we fall through the + * loop it can only mean that we have an unrecognized escape sequence, + * so discard it and return in command mode. + */ + g_ungetc (ch); + return (ALPHA_MODE); + +action: + /* Process the escape sequence. */ + switch (tag) { + case ESC_SETTEXTMODE: + tx_len = 0; + sl_x = sl_xoff; + if (sl_rect_saved) + sl_restore_rect(); + else + sl_save_rect(); + return (TEXT_MODE); + + case ESC_ENQUIRE: + gio_retenq(); + break; + case ESC_READCURSOR: + return (CURSOR_MODE); + case ESC_SETCURSOR: + gio_setcursorpos (cur_x, cur_y); + break; + + case ESC_CLEARSCREEN: + pw_writebackground (pw, 0, 0, win_xres, win_yres, PIX_SRC); + tx_leftmargin = 0; + cur_x = tx_leftmargin; + cur_y = tx_charbase; + ohiy = 0; oloy = 0; + ohix = 0; olox = 0; + gio_datalevel = SET_BITS; + pl_linestyle = 0; + pl_linewidth = 1; + pl_pointmode = 0; + sl_rect_saved = 0; + chcur_on = 0; + chcur_skip = 0; + return (ALPHA_MODE); + + case ESC_SETCHARSIZE0: + case ESC_SETCHARSIZE1: + case ESC_SETCHARSIZE2: + case ESC_SETCHARSIZE3: + /* Ignore these for now. */ + break; + + case ESC_SETDATALEVEL0: + gio_datalevel = SET_BITS; + break; + case ESC_SETDATALEVEL1: + gio_datalevel = CLEAR_BITS; + break; + case ESC_SETDATALEVEL2: + gio_datalevel = TOGGLE_BITS; + break; + + case ESC_SETLINESTYLE0: + pl_linestyle = 0; + break; + case ESC_SETLINESTYLE1: + pl_linestyle = 1; + break; + case ESC_SETLINESTYLE2: + pl_linestyle = 2; + break; + case ESC_SETLINESTYLE3: + pl_linestyle = 3; + break; + case ESC_SETLINESTYLE4: + pl_linestyle = 4; + break; + + case ESC_SETLINEWIDTH0: + pl_linewidth = 1; + break; + case ESC_SETLINEWIDTH1: + pl_linewidth = 2; + break; + case ESC_SETLINEWIDTH2: + pl_linewidth = 3; + break; + default: + ; + } + + return (COMMAND_MODE); +} + + +/* UPDATE_CURSOR -- Update the state of the alpha mode cursor, used to mark + * the position of the next character on the screen when in alpha mode. + * In any other mode this cursor is turned off. + */ +update_cursor() +{ + erase_cursor(); + if (gio_mode == ALPHA_MODE && chcur_skip++ >= 0) { + /* Update the position of the alpha character cursor. + */ + pw_text (pw, cur_x, cur_y, + PIX_NOT(PIX_DST), alpha_font->pixfont, " "); + chcur_font = alpha_font; + chcur_x = cur_x; + chcur_y = cur_y; + chcur_on = 1; + + /* Turn the mouse cursor on too, if currently disabled. + */ + gio_setcursor (CURSOR_ON, 0); + } +} + + +/* ERASE_CURSOR -- If the character cursor is currently displayed, restore the + * character under the cursor to its former state. + */ +erase_cursor() +{ + if (chcur_on) { + pw_text (pw, chcur_x, chcur_y, + PIX_NOT(PIX_DST), chcur_font->pixfont, " "); + chcur_on = 0; + } +} + + +/* SL_SAVE_RECT -- Make a copy of the status line pixrect in a memory + * pixrect, so that we can later "erase" the status line by overwriting + * it with the saved data rect. + */ +sl_save_rect() +{ + if (sl_pr) { + pw_read (sl_pr, 0, 0, sl_width, sl_height, PIX_SRC, + pw, sl_xoff, sl_yoff - sl_cbase); + sl_rect_saved = 1; + } +} + + +/* SL_RESTORE_RECT -- Restore the saved status line data pixrect. + */ +sl_restore_rect() +{ + if (sl_pr) + pw_write (pw, sl_xoff, sl_yoff - sl_cbase, sl_width, sl_height, + PIX_SRC, sl_pr, 0, 0); +} + + +/* GIO_ROP -- Return the raster op appropriate for the datalevel control + * option set by the user, i.e, set, clear, or toggle bits. + */ +gio_rop() +{ + register int rop; + + switch (gio_datalevel) { + case SET_BITS: + rop = PIX_SRC | PIX_DST; + break; + case CLEAR_BITS: + rop = PIX_NOT(PIX_SRC) & PIX_DST; + break; + case TOGGLE_BITS: + rop = PIX_SRC ^ PIX_DST; + break; + default: + rop = PIX_SRC; + break; + } + + if (!clip_graphics) + rop |= PIX_DONTCLIP; + + return (rop); +} + + +#define NLINETYPES 5 +static short lt_dashed[] = { 8, 3, 8, 3, 8, 3, 8, 3, 0 }; +static short lt_dotted[] = { 2, 3, 2, 3, 2, 3, 2, 3, 0 }; +static short lt_dashdot[] = { 14, 3, 1, 3, 14, 3, 1, 3, 0 }; +static short lt_dash3dot[] = { 20, 3, 1, 3, 1, 3, 1, 3, 0 }; + +static short *lt_pattern[] = { + NULL, + lt_dashed, + lt_dotted, + lt_dashdot, + lt_dash3dot +}; + + +/* PL_TEXTURE -- Return a pointer to a texture descriptor (Breshingham + * dashed line drawing algorithm) to be used to draw a dashed polyline. + * The case linetype==0 is special, signifying a solid line. The descriptor + * must be initialized to a known state, i.e., zeroed, on each call or + * the pixrect polyline code will produce garbage. + */ +static Pr_texture * +pl_texture (linetype) +int linetype; +{ + register char *p; + register int n; + static Pr_texture tex; + short *pattern; + + if (linetype == 0) + return (NULL); /* solid line */ + else + pattern = lt_pattern[linetype % NLINETYPES]; + + for (p=(char *)(&tex), n=sizeof(tex); --n >= 0; ) + *p++ = NULL; + + tex.pattern = pattern; + tex.options.givenpattern = 1; + + return (&tex); +} diff --git a/unix/sun/halley.lut b/unix/sun/halley.lut new file mode 100644 index 00000000..ac00326a --- /dev/null +++ b/unix/sun/halley.lut @@ -0,0 +1,257 @@ +256, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.86275, +0.00000, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.51765, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98431, 0.81176, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 1.00000, +0.00000, 1.00000, 1.00000, +0.47059, 0.78431, 1.00000, +0.47059, 0.78431, 1.00000, +0.47059, 0.78431, 1.00000, +0.62745, 0.62745, 1.00000, +0.62745, 0.62745, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +1.00000, 0.70588, 1.00000, +1.00000, 0.70588, 1.00000, +1.00000, 0.76863, 1.00000, +1.00000, 0.86275, 1.00000, +1.00000, 0.86275, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 0.89804, 1.00000, +1.00000, 0.86275, 1.00000, +1.00000, 0.86275, 1.00000, +1.00000, 0.86275, 1.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.92157, 0.61961, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.78431, 0.47059, 1.00000, +0.65882, 0.59608, 1.00000, +0.62745, 0.62745, 1.00000, +0.62745, 0.62745, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +0.00000, 0.00000, 1.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.70588, +0.00000, 1.00000, 0.65490, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.00000, 1.00000, 0.00000, +0.36078, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.70588, 1.00000, 0.00000, +0.98431, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +1.00000, 1.00000, 0.00000, +0.99608, 0.97647, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98431, 0.85098, 0.00000, +0.98824, 0.77647, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +0.98824, 0.72549, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.36863, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.00000, +1.00000, 0.00000, 0.46667, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 0.70588, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +1.00000, 0.00000, 1.00000, +0.91373, 0.00000, 0.97255, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.70588, 0.00000, 0.90196, +0.53333, 0.00000, 0.87451, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +0.47059, 0.00000, 0.86275, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +1.00000, 1.00000, 1.00000, +0.00000, 0.00000, 0.86275, +0.00000, 0.00000, 0.86275, +0.00000, 0.00000, 0.86275, +0.00000, 0.00000, 0.86275, +0.00000, 0.00000, 0.80392, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.70588, +0.00000, 0.00000, 0.13725, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000, +0.00000, 0.00000, 0.00000 diff --git a/unix/sun/heat.lut b/unix/sun/heat.lut new file mode 100644 index 00000000..124a70f4 --- /dev/null +++ b/unix/sun/heat.lut @@ -0,0 +1,257 @@ +256, +0.00000, 0.00000, 0.00000, +0.01176, 0.00392, 0.00000, +0.02353, 0.00784, 0.00000, +0.03529, 0.01176, 0.00000, +0.04706, 0.01569, 0.00000, +0.05882, 0.01961, 0.00000, +0.07059, 0.02353, 0.00000, +0.08235, 0.02745, 0.00000, +0.09412, 0.03137, 0.00000, +0.10588, 0.03529, 0.00000, +0.11765, 0.03922, 0.00000, +0.12941, 0.04314, 0.00000, +0.14118, 0.04706, 0.00000, +0.15294, 0.05098, 0.00000, +0.16471, 0.05490, 0.00000, +0.17647, 0.05882, 0.00000, +0.18824, 0.06275, 0.00000, +0.20000, 0.06667, 0.00000, +0.21176, 0.07059, 0.00000, +0.22353, 0.07451, 0.00000, +0.23529, 0.07843, 0.00000, +0.24706, 0.08235, 0.00000, +0.25882, 0.08627, 0.00000, +0.27059, 0.09020, 0.00000, +0.28235, 0.09412, 0.00000, +0.29412, 0.09804, 0.00000, +0.30588, 0.10196, 0.00000, +0.31765, 0.10588, 0.00000, +0.32941, 0.10980, 0.00000, +0.34118, 0.11373, 0.00000, +0.35294, 0.11765, 0.00000, +0.36471, 0.12157, 0.00000, +0.37647, 0.12549, 0.00000, +0.38824, 0.12941, 0.00000, +0.40000, 0.13333, 0.00000, +0.41176, 0.13725, 0.00000, +0.42353, 0.14118, 0.00000, +0.43529, 0.14510, 0.00000, +0.44706, 0.14902, 0.00000, +0.45882, 0.15294, 0.00000, +0.47059, 0.15686, 0.00000, +0.48235, 0.16078, 0.00000, +0.49412, 0.16471, 0.00000, +0.50588, 0.16863, 0.00000, +0.51765, 0.17255, 0.00000, +0.52941, 0.17647, 0.00000, +0.54118, 0.18039, 0.00000, +0.55294, 0.18431, 0.00000, +0.56471, 0.18824, 0.00000, +0.57647, 0.19216, 0.00000, +0.58824, 0.19608, 0.00000, +0.60000, 0.20000, 0.00000, +0.61176, 0.20392, 0.00000, +0.62353, 0.20784, 0.00000, +0.63529, 0.21176, 0.00000, +0.64706, 0.21569, 0.00000, +0.65882, 0.21961, 0.00000, +0.67059, 0.22353, 0.00000, +0.68235, 0.22745, 0.00000, +0.69412, 0.23137, 0.00000, +0.70588, 0.23529, 0.00000, +0.71765, 0.23922, 0.00000, +0.72941, 0.24314, 0.00000, +0.74118, 0.24706, 0.00000, +0.75294, 0.25098, 0.00000, +0.76471, 0.25490, 0.00000, +0.77647, 0.25882, 0.00000, +0.78824, 0.26275, 0.00000, +0.80000, 0.26667, 0.00000, +0.81176, 0.27059, 0.00000, +0.82353, 0.27451, 0.00000, +0.83529, 0.27843, 0.00000, +0.84706, 0.28235, 0.00000, +0.85882, 0.28627, 0.00000, +0.87059, 0.29020, 0.00000, +0.88235, 0.29412, 0.00000, +0.89412, 0.29804, 0.00000, +0.90588, 0.30196, 0.00000, +0.91765, 0.30588, 0.00000, +0.92941, 0.30980, 0.00000, +0.94118, 0.31373, 0.00000, +0.95294, 0.31765, 0.00000, +0.96471, 0.32157, 0.00000, +0.97647, 0.32549, 0.00000, +0.98824, 0.32941, 0.00000, +1.00000, 0.33333, 0.00000, +1.00000, 0.33725, 0.00000, +1.00000, 0.34118, 0.00000, +1.00000, 0.34510, 0.00000, +1.00000, 0.34902, 0.00000, +1.00000, 0.35294, 0.00000, +1.00000, 0.35686, 0.00000, +1.00000, 0.36078, 0.00000, +1.00000, 0.36471, 0.00000, +1.00000, 0.36863, 0.00000, +1.00000, 0.37255, 0.00000, +1.00000, 0.37647, 0.00000, +1.00000, 0.38039, 0.00000, +1.00000, 0.38431, 0.00000, +1.00000, 0.38824, 0.00000, +1.00000, 0.39216, 0.00000, +1.00000, 0.39608, 0.00000, +1.00000, 0.40000, 0.00000, +1.00000, 0.40392, 0.00000, +1.00000, 0.40784, 0.00000, +1.00000, 0.41176, 0.00000, +1.00000, 0.41569, 0.00000, +1.00000, 0.41961, 0.00000, +1.00000, 0.42353, 0.00000, +1.00000, 0.42745, 0.00000, +1.00000, 0.43137, 0.00000, +1.00000, 0.43529, 0.00000, +1.00000, 0.43922, 0.00000, +1.00000, 0.44314, 0.00000, +1.00000, 0.44706, 0.00000, +1.00000, 0.45098, 0.00000, +1.00000, 0.45490, 0.00000, +1.00000, 0.45882, 0.00000, +1.00000, 0.46275, 0.00000, +1.00000, 0.46667, 0.00000, +1.00000, 0.47059, 0.00000, +1.00000, 0.47451, 0.00000, +1.00000, 0.47843, 0.00000, +1.00000, 0.48235, 0.00000, +1.00000, 0.48627, 0.00000, +1.00000, 0.49020, 0.00000, +1.00000, 0.49412, 0.00000, +1.00000, 0.49804, 0.00000, +1.00000, 0.50196, 0.00000, +1.00000, 0.50588, 0.00000, +1.00000, 0.50980, 0.00000, +1.00000, 0.51373, 0.00000, +1.00000, 0.51765, 0.00000, +1.00000, 0.52157, 0.00000, +1.00000, 0.52549, 0.00000, +1.00000, 0.52941, 0.00000, +1.00000, 0.53333, 0.00000, +1.00000, 0.53725, 0.00000, +1.00000, 0.54118, 0.00000, +1.00000, 0.54510, 0.00000, +1.00000, 0.54902, 0.00000, +1.00000, 0.55294, 0.00000, +1.00000, 0.55686, 0.00000, +1.00000, 0.56078, 0.00000, +1.00000, 0.56471, 0.00000, +1.00000, 0.56863, 0.00000, +1.00000, 0.57255, 0.00000, +1.00000, 0.57647, 0.00000, +1.00000, 0.58039, 0.00000, +1.00000, 0.58431, 0.00000, +1.00000, 0.58824, 0.00000, +1.00000, 0.59216, 0.00000, +1.00000, 0.59608, 0.00000, +1.00000, 0.60000, 0.00000, +1.00000, 0.60392, 0.00000, +1.00000, 0.60784, 0.00000, +1.00000, 0.61176, 0.00000, +1.00000, 0.61569, 0.00000, +1.00000, 0.61961, 0.00000, +1.00000, 0.62353, 0.00000, +1.00000, 0.62745, 0.00000, +1.00000, 0.63137, 0.00000, +1.00000, 0.63529, 0.00000, +1.00000, 0.63922, 0.00000, +1.00000, 0.64314, 0.00000, +1.00000, 0.64706, 0.00000, +1.00000, 0.65098, 0.01176, +1.00000, 0.65490, 0.02353, +1.00000, 0.65882, 0.03529, +1.00000, 0.66275, 0.04706, +1.00000, 0.66667, 0.05882, +1.00000, 0.67059, 0.07059, +1.00000, 0.67451, 0.08235, +1.00000, 0.67843, 0.09412, +1.00000, 0.68235, 0.10588, +1.00000, 0.68627, 0.11765, +1.00000, 0.69020, 0.12941, +1.00000, 0.69412, 0.14118, +1.00000, 0.69804, 0.15294, +1.00000, 0.70196, 0.16471, +1.00000, 0.70588, 0.17647, +1.00000, 0.70980, 0.18824, +1.00000, 0.71373, 0.20000, +1.00000, 0.71765, 0.21176, +1.00000, 0.72157, 0.22353, +1.00000, 0.72549, 0.23529, +1.00000, 0.72941, 0.24706, +1.00000, 0.73333, 0.25882, +1.00000, 0.73725, 0.27059, +1.00000, 0.74118, 0.28235, +1.00000, 0.74510, 0.29412, +1.00000, 0.74902, 0.30588, +1.00000, 0.75294, 0.31765, +1.00000, 0.75686, 0.32941, +1.00000, 0.76078, 0.34118, +1.00000, 0.76471, 0.35294, +1.00000, 0.76863, 0.36471, +1.00000, 0.77255, 0.37647, +1.00000, 0.77647, 0.38824, +1.00000, 0.78039, 0.40000, +1.00000, 0.78431, 0.41176, +1.00000, 0.78824, 0.42353, +1.00000, 0.79216, 0.43529, +1.00000, 0.79608, 0.44706, +1.00000, 0.80000, 0.45882, +1.00000, 0.80392, 0.47059, +1.00000, 0.80784, 0.48235, +1.00000, 0.81176, 0.49412, +1.00000, 0.81569, 0.50588, +1.00000, 0.81961, 0.51765, +1.00000, 0.82353, 0.52941, +1.00000, 0.82745, 0.54118, +1.00000, 0.83137, 0.55294, +1.00000, 0.83529, 0.56471, +1.00000, 0.83922, 0.57647, +1.00000, 0.84314, 0.58824, +1.00000, 0.84706, 0.60000, +1.00000, 0.85098, 0.61176, +1.00000, 0.85490, 0.62353, +1.00000, 0.85882, 0.63529, +1.00000, 0.86275, 0.64706, +1.00000, 0.86667, 0.65882, +1.00000, 0.87059, 0.67059, +1.00000, 0.87451, 0.68235, +1.00000, 0.87843, 0.69412, +1.00000, 0.88235, 0.70588, +1.00000, 0.88627, 0.71765, +1.00000, 0.89020, 0.72941, +1.00000, 0.89412, 0.74118, +1.00000, 0.89804, 0.75294, +1.00000, 0.90196, 0.76471, +1.00000, 0.90588, 0.77647, +1.00000, 0.90980, 0.78824, +1.00000, 0.91373, 0.80000, +1.00000, 0.91765, 0.81176, +1.00000, 0.92157, 0.82353, +1.00000, 0.92549, 0.83529, +1.00000, 0.92941, 0.84706, +1.00000, 0.93333, 0.85882, +1.00000, 0.93725, 0.87059, +1.00000, 0.94118, 0.88235, +1.00000, 0.94510, 0.89412, +1.00000, 0.94902, 0.90588, +1.00000, 0.95294, 0.91765, +1.00000, 0.95686, 0.92941, +1.00000, 0.96078, 0.94118, +1.00000, 0.96471, 0.95294, +1.00000, 0.96863, 0.96471, +1.00000, 0.97255, 0.97647, +1.00000, 0.97647, 0.98824, +1.00000, 0.98039, 1.00000, +1.00000, 0.98431, 1.00000, +1.00000, 0.98824, 1.00000, +1.00000, 0.99216, 1.00000, +1.00000, 0.99608, 1.00000, +1.00000, 1.00000, 1.00000 diff --git a/unix/sun/imtool.c b/unix/sun/imtool.c new file mode 100644 index 00000000..6c055610 --- /dev/null +++ b/unix/sun/imtool.c @@ -0,0 +1,4488 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <suntool/sunview.h> +#include <suntool/canvas.h> +#include <suntool/panel.h> +#include <suntool/walkmenu.h> +#include <suntool/tool_struct.h> +#include <sunwindow/win_cursor.h> +#include <sys/fcntl.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <stdio.h> +#include <ctype.h> +#include <math.h> +#include "imtool.h" + +/* + * IMTOOL -- Software image display for the Sun workstation under Sunview. + * A variable sized window is used to peer into a "fixed" size frame buffer + * at an arbitrary offset (pan) and scale (zoom/dezoom). The number of frames + * and the size of a frame buffer is arbitrary and is a setup option. The + * depth of a frame on an 8 bit display is 7 bits with a 1 bit graphics + * overlay plane; this leaves almost half of the color table space for use + * by other windows. A data stream command interface is provided for software + * control of the display server by other processes, not necessarily on the + * same node. + * + * D.Tody, April 1987 (NOAO/IRAF project) + * Extensively revised and extended December 1987. + * Zoom and further datastream mods (WCS) added May 1989. + * (but NeWS/X is coming soon and probably none of this will work anymore...) + */ + +#ifndef abs +#define abs(a) (((a)<0)?(-(a)):(a)) +#endif + +#ifndef min +#define min(a,b) ((a)<(b)?(a):(b)) +#endif +#ifndef max +#define max(a,b) ((a)<(b)?(b):(a)) +#endif + +/* Default values, size limiting values. + */ +#define MAX_ARGS 50 /* max command line arguments */ +#define MAX_FBCONFIG 128 /* max possible frame buf sizes */ +#define MAX_FRAMES 16 /* max number of frames */ +#define FRAME_CHOICES "1","2","3","4" /* nframes choices for setup */ +#define NGREY 256 /* max physical greylevels */ +#define CLOCK_INTERVAL 500 /* main clock tick, msec */ +#define DEF_NCONFIG 1 /* number of f.b. configs */ +#define DEF_NFRAMES 1 /* save memory; only one frame */ +#define DEF_FRAME_WIDTH 512 /* 512 square frame */ +#define DEF_FRAME_HEIGHT 512 /* 512 square frame */ +#define DEF_GIOWIN_SIZE 512 /* default size gio window */ +#define SZ_LABEL 256 /* main frame label string */ +#define SZ_IMTITLE 128 /* image title string */ +#define SZ_WCTEXT 80 /* WCS box text */ +#define SZ_WCSBUF 320 /* WCS text buffer size */ +#define SZ_PANTEXT 18 /* displayed chars in o_fname */ +#define SZ_COLORBAR 11 /* height of colorbar in pixels */ +#define SZ_FNAME 128 +#define SZ_LINE 256 +#define IO_TIMEOUT 30 /* i/o not getting anywhere */ +#define SZ_FIFOBUF 4000 /* transfer size for FIFO i/o */ +#define BKG_WHITE 0 +#define BKG_BLACK 1 +#define P_IMAGE 1 +#define P_GRAPHICS 2 +#define P_COLORBAR 4 +#define P_DONTCLIP 8 +#define PANNER_EVENT 99 +#define INTERRUPT 003 +#define NEXT_SCREEN 006 +#define PREV_SCREEN 022 +#define CYCLE_BLINK 002 + +/* Reserved colormap entries. + */ +#define CMS_DATASTART 1 /* first data greylevel */ +#define CMS_DATAEND 200 /* last data greylevel */ +#define CMS_DATARANGE 200 /* number of data greylevels */ +#define CMS_CURSOR 201 /* cursor color table entry */ +#define CMS_BACKGROUND 202 /* background color */ +#define CMS_GRAPHICSSTART 203 /* first graphics greylevel */ +#define CMS_GRAPHICSEND 217 /* last graphics greylevel */ +#define CMS_GRAPHICSRANGE 15 /* number of graphics greylevel */ +#define CMS_GCOLOR(c) (203+(c)) /* graphics color table entries */ +#define CMS_FIRST 1 /* first grey level used */ +#define CMS_NGREY 218 /* total number of grey levels */ + +/* Magic numbers. */ +#define BLINK_OFF 1 /* crosshair cursor off */ +#define BLINK_ON 2 /* turn crosshair cursor on */ +#define CMMAPNAME "imtool" /* color map segment name */ +#define OLD_DEVNAME "/dev/imt1" /* original pseudodevice name */ +#define I_DEVNAME "/dev/imt1o" /* pseudo device names */ +#define O_DEVNAME "/dev/imt1i" /* our IN is client's OUT */ +#define KEY_SETUP KEY_TOP(4) /* togglt the setup panel */ +#define KEY_REMARK KEY_TOP(5) /* remark list of objects */ +#define KEY_PCOORDS KEY_TOP(6) /* cont. coords display */ +#define KEY_SNAP KEY_TOP(7) /* image hardcopy key */ +#define TEXT_FONT "/usr/lib/fonts/fixedwidthfonts/screen.b.14" +#define MARK_FONT "/usr/lib/fonts/fixedwidthfonts/screen.r.11" +#define COORDFILE "frame.%d.%d" +#define FBCONFIG_1 ".imtoolrc" +#define FBCONFIG_2 "/usr/local/lib/imtoolrc" +#define FBCONFIG_ENV1 "imtoolrc" +#define FBCONFIG_ENV2 "IMTOOLRC" + +#define R_TYPE 0 /* 0=postscript, 1=rasterfile */ +#define R_DISPOSE "lpr -s %s" /* dispose command */ +#define R_FILENAME "" /* output filename */ + +/* Global state codes. */ +#define TRACK_CURSOR 0 +#define WINDOW 1 +#define ROAM 2 + +#define MONO 0 +#define HEAT 1 +#define RAMP1 2 +#define RAMP2 3 +#define HALLEY 4 +#define LINEARPS 5 +#define RANDOMPS 6 +#define CRANDOMPS 7 +#define ULUT1 8 +#define ULUT2 9 + +/* WCS definitions. */ +#define W_UNITARY 0 +#define W_LINEAR 1 +#define W_LOG 2 +#define W_DEFFORMAT " %7.2f %7.2f %7.1f%c" + +/* Internal variables. */ +static int snap_frame_too = 1; /* include frame in imcopy? */ +static int cursor_blink = -1; /* crosshair or small cursor */ +static int cursor_show = -1; /* cursor state; on/off */ +static int display_coords = 0; /* cont. display cursor coords */ +static int p_cursor_setback = 0; /* restore cursor pos after pan */ +static int panning = 0; /* smooth image pan in progress */ +static int maptype = MONO; /* initial mapping type */ +static char o_fname[SZ_FNAME]; /* name of coord output file */ +static char o_revtext=1; /* reverse video text? */ +static int setup_xoff = 4; /* offset to setup panel */ +static int setup_yoff = 18; /* " " */ +static int wc_xoff=0, wc_yoff=0; /* offset to WCS output box */ +static int wc_width, wc_height; /* size of WCS output box */ +static char wc_text[SZ_WCTEXT+1]; /* coordinate text */ +static struct pixfont *wc_font = NULL; /* WCS box font */ +static int cb_height = SZ_COLORBAR; +static int show_colorbar = 1; +static int black = 0; +static int white = NGREY - 1; +static int background = 0; /* background color index */ +static int state = TRACK_CURSOR; /* mouse button state */ +static int last_sx, last_sy; /* window x,y of last event */ +static int save_sx, save_sy; /* save absolute mouse position */ +static int last_bx, last_by; /* last button press */ +static int fb_bkgcolor_index = BKG_WHITE; +static int window_open = 1; +static int global_colortable = 1; /* globally manage colortable */ +static int fbconfig = 0; +static int last_x, last_y, last_key, key_left=0; +static int reading_imcursor = 0; +static int imcursor_wcs; +static char wcsbuf[MAX_FRAMES][SZ_WCSBUF]; + +#define CRANDOM_CHOICES "1", "2", "4", "8", "16", "32" +static int cr_msec[] = { 1000, 2000, 4000, 8000, 16000, 32000 }; +static int crandom_blink_rate = 1; /* rate for cont. random pseudo */ + +/* Blink parameters. */ +#define BLINKRATE_CHOICES "1/2","1","2","4","8","16","32" +static int blink_rate[] = { 1, 2, 4, 8, 16, 32, 64 }; +static int blink_rate_index = 1; /* current blink rate */ +static int blink_timer = 0; /* nticks left on clock */ +static int blink_frame = 0; /* current blink frame */ +static int blink = 0; /* blink enabled? */ +static int n_blink_frames = 8; /* number of frames to blink */ +static int blink_frames[MAX_FRAMES] = { 1, 2, 3, 4, 5, 6, 7, 8 }; +static char s_blinklist[SZ_FNAME+1] = "all"; /* list of frames to blink */ + +/* Logical image cursor parameters. */ +static int marktype = 0; /* mark cursor position */ + +/* The following is needed to provide sufficient precision to allow for + * zooming virtual pixrects (Rects use type short). + */ +typedef struct bigrect { + int r_left, r_top; + int r_width, r_height; +} BRect; + +/* Predefined lookup tables. */ +struct triplet { + float red, green, blue; +}; +struct lut { + int lutlen; + struct triplet hue[NGREY]; +}; + +struct lut heat = { +#include "heat.lut" +}; + +struct lut halley = { +#include "halley.lut" +}; + +/* User defined lookup tables. */ +static char u_lut1[SZ_FNAME+1] = "none"; +static char u_lut2[SZ_FNAME+1] = "none"; + +static BRect pw_rect; /* raw frame buffer */ +static int fb_depth = 8; +static int fb_ngrey = CMS_DATARANGE; +static int fb_nframes= DEF_NFRAMES; +static int Fb_width = DEF_FRAME_WIDTH; +static int Fb_height = DEF_FRAME_HEIGHT; + +static BRect fb_rect; /* zoomed frame buffer */ +static int fb_width = DEF_FRAME_WIDTH; +static int fb_height = DEF_FRAME_HEIGHT; + +#define MAX_ZOOMS 8 +#define ZOOM_CHOICES "1","2","4","8" +static int zoom = 1; +static int nzooms = 4; /* number of zoom factors */ +static int zoom_index = 0; +static int zooms[MAX_ZOOMS] = { 1, 2, 4, 8 }; +static char s_zoomslist[SZ_FNAME+1] = "1 2 4 8"; + +static int gio_xsize = DEF_GIOWIN_SIZE; +static int gio_ysize = DEF_GIOWIN_SIZE; +static int initial_gio_xsize, initial_gio_ysize; + +/* Rotation matrix defining world coordinate system (WCS) of a frame. + */ +struct ctran { + int valid; /* has WCS been set? */ + float a, b; /* x, y scale factors */ + float c, d; /* x, y cross factors */ + float tx, ty; /* x, y translation */ + float z1, z2; /* greyscale range */ + int zt; /* greyscale mapping */ + char format[32]; /* wcs output format */ + char imtitle[SZ_IMTITLE+1]; /* image title from WCS */ +}; + +/* The frame buffers. */ +struct framebuf { + struct pixrect *fb_pr; /* frame buffer pixrect */ + int fb_frameno; /* frame number */ + int fb_xoff, fb_yoff; /* fb coords of pixwin (0,0) */ + int fb_xzoom, fb_yzoom; /* zoom/dezoom factors */ + int fb_objno; /* object number */ + int fb_imageno; /* displayed frame counter */ + int fb_maptype; /* greyscale transformation */ + float fb_center, fb_slope; /* transfer function */ + struct ctran fb_ctran; /* world coordinate system */ + char fb_label[SZ_LABEL+1]; /* frame label string */ +}; + +/* Possible frame buffer sizes. */ +struct fbconfig { + int nframes; /* number of frames */ + int width; /* frame buffer width */ + int height; /* frame buffer height */ +}; + +static int display_frame; /* currently displayed frame */ +static int reference_frame; /* reference (cmd i/o) frame */ +static struct framebuf *frames=NULL; /* array of frame descriptors */ +static struct framebuf *df_p; /* display frame descriptor */ +static struct framebuf *rf_p; /* reference frame descriptor */ +static struct pixrect *cb_pr; /* colorbar pixrect */ +static int fb_nconfig = 0; +static int fb_config_index = 0; +static struct fbconfig fb_config[MAX_FBCONFIG]; +static char startfile[SZ_FNAME+1]; /* image read on startup */ +static char rasterfile[SZ_FNAME+1] = "raster.%d.%d"; + +/* Screendump stuff. */ +int r_type = R_TYPE; +char r_dispose[SZ_FNAME+1] = R_DISPOSE; +char r_filename[SZ_FNAME+1] = R_FILENAME; + +#define HEIGHTADJUST \ + (tool_headerheight((int)window_get(gio_frame, FRAME_SHOW_LABEL)) + \ + TOOL_BORDERWIDTH) + +static short iconimage[] = { +#include "imtool.icon" +}; +DEFINE_ICON_FROM_IMAGE (icon, iconimage); + +Window gio_frame, gio_canvas; +static int gio_frame_fd; +static int datain, dataout; +static Menu_item blink_item; +static Panel setup_panel; +static Window setup_frame; +static Panel_item pan_show_colorbar, pan_globalcolor; +static Panel_item pan_set_nframes, pan_blink_rate, pan_blink_list; +static Panel_item pan_set_maptype, pan_crandom_rate, pan_set_ofname; +static Panel_item pan_snapframetoo, pan_set_background, pan_set_rfname; +static Panel_item pan_set_rtype, pan_set_rdispose, pan_set_rfilename; +static Panel_item pan_set_marker, pan_zoom_list; +static Panel_item pan_set_ulut1, pan_set_ulut2; +static unsigned char red[NGREY], blue[NGREY], green[NGREY]; +static unsigned char m_red[NGREY], m_blue[NGREY], m_green[NGREY]; + +static struct pixwin *gio_pw; +static int main_argc, gio_argc; +static char **main_argv, *gio_argv[MAX_ARGS]; + +static Notify_value ev_gioframe(), set_colortable(); +static Notify_value ev_gioinput(), ev_cmdinput(), ev_panner(); +static char *getfname(), *framelabel(); +static struct ctran *wcs_update(); +static struct pixrect *get_screen_rect(); +static refresh_display(); +extern char *getenv(); + + +/* IMTOOL_MAIN -- Create the Imtool windows, i.e., the main display window, + * the region of interest or "cursor" subwindow, and the setup panel. There + * are two principal event handlers, the display window event handler, used + * to process cursor input and mouse button commands, and the command input + * event handler, used to communicate with the client process. + */ +#ifdef STANDALONE +main (argc, argv) +#else +imtool_main (argc, argv) +#endif +int argc; +char **argv; +{ + char *s; + + main_argc = argc; + main_argv = argv; + parse_args (argc, argv, &gio_argc, gio_argv); + + /* Screendump stuff. */ + if (s = getenv ("R_DISPOSE")) + strcpy (r_dispose, s); + if (s = getenv ("R_FILENAME")) + strcpy (r_filename, s); + if (s = getenv ("R_RASTERFILE")) { + strcpy (r_filename, s); + r_type = 1; + } + + gio_frame = window_create (NULL, FRAME, + FRAME_ICON, &icon, + FRAME_LABEL, + "imtool - NOAO/IRAF Sunview Image Display V1.1", + FRAME_ARGS, gio_argc, gio_argv, + FRAME_NO_CONFIRM, FALSE, + 0); + if (gio_frame == NULL) + exit (1); + + gio_frame_fd = (int) window_get (gio_frame, WIN_FD); + parse_args (argc, argv, &gio_argc, gio_argv); + create_gio_canvas (gio_argc, gio_argv); + create_frame_menu (gio_frame); + create_setup_popup(); + notify_interpose_event_func (gio_frame, ev_gioframe, NOTIFY_SAFE); + notify_interpose_event_func (gio_canvas, ev_gioinput, NOTIFY_SAFE); + + get_fbconfig(); + set_fbconfig (fbconfig, 0); + load_testpattern (0); + set_colortable(); + gio_setcursor (CURSOR_ON, BLINK_OFF); + set_transfer_function (gio_pw, df_p->fb_center, df_p->fb_slope); + + Bpw_get_region_rect (gio_pw, &pw_rect); + pw_rect.r_left = df_p->fb_xoff; + pw_rect.r_top = df_p->fb_yoff; + init_colorbar (pw_rect.r_width); + + if (startfile[0]) + load_raster (rf_p->fb_pr, startfile); + + initial_gio_xsize = gio_xsize; + initial_gio_ysize = gio_ysize; + + /* Open the output fifo. We have to open it ourselves first as a + * client to get around the fifo open-no-client error. + */ + if ((datain = open (O_DEVNAME, O_RDONLY|O_NDELAY)) != -1) { + if ((dataout = open (O_DEVNAME, O_WRONLY|O_NDELAY)) != -1) + fcntl (dataout, F_SETFL, O_WRONLY); + close (datain); + } + + /* Open the input stream, a FIFO pseudodevice file used by + * applications to send us commands and data. + */ + if ((datain = open (I_DEVNAME, O_RDONLY|O_NDELAY)) == -1) { + if ((datain = open (OLD_DEVNAME, O_RDONLY|O_NDELAY)) == -1) + fprintf (stderr, "Warning: cannot open %s\n", I_DEVNAME); + } else { + /* Clear O_NDELAY for reading. */ + fcntl (datain, F_SETFL, O_RDONLY); + notify_set_input_func (gio_frame, ev_cmdinput, datain); + } + + imtool_clock(); + window_main_loop (gio_frame); + close (datain); + exit (0); +} + + +/* PARSE_ARGS -- Parse the argument list into the arguments for the main frame + * and the global arguments for the server. + */ +static +parse_args (argc, argv, gio_argc, gio_argv) +int argc; +char *argv[]; +int *gio_argc; +char *gio_argv[]; +{ + register char *argp; + register int arg; + static int ncalls = 0; + + gio_argv[0] = argv[0]; + *gio_argc = 1; + + for (arg=1; arg <= argc && (argp = argv[arg]) != NULL; arg++) { + if (strncmp (argp, "-fbconfig", 3) == 0) { + /* Set the frame buffer configuration. */ + if ((argp = argv[arg+1]) && isdigit(*argp)) { + fbconfig = max (0, atoi(argp) - 1); + arg++; + } else if (ncalls == 0) + fprintf (stderr, "-fbconfig argument missing\n"); + } else if (strncmp (argp, "-raster", 4) == 0) { + if ((argp = argv[arg+1])) { + strcpy (startfile, argp); + arg++; + } + } else + gio_argv[(*gio_argc)++] = argp; + } + + gio_argv[(*gio_argc)] = NULL; + ncalls++; +} + + +/* GET_FBCONFIG -- Read the IMTOOL startup file to get the set of possible + * frame buffer sizes. + * + * File format: configno nframes width height [extra fields] + * e.g., 1 2 512 512 + * 2 2 800 800 + * 3 1 1024 1024 # comment + */ +static +get_fbconfig() +{ + register char *ip; + register FILE *fp; + int config, nframes, width, height, i; + char lbuf[SZ_LINE+1], *fname; + + /* Initialize the config table. */ + for (i=0; i < MAX_FBCONFIG; i++) + fb_config[i].nframes = 0; + + /* Attempt to open the config file. */ + fp = NULL; + if ((fname=getenv(FBCONFIG_ENV1)) || (fname=getenv(FBCONFIG_ENV2))) + fp = fopen (fname, "r"); + if (!fp && (fname = getenv ("HOME"))) { + sprintf (lbuf, "%s/%s", fname, FBCONFIG_1); + fp = fopen (fname = lbuf, "r"); + } + if (!fp) + fp = fopen (fname = FBCONFIG_2, "r"); + + /* If cannot find a config file, set up the default configuration. */ + if (!fp) { + fb_config_index = fbconfig = 0; + fb_nconfig = DEF_NCONFIG; + fb_config[0].nframes = DEF_NFRAMES; + fb_config[0].width = DEF_FRAME_WIDTH; + fb_config[0].height = DEF_FRAME_HEIGHT; + return; + } + + /* Scan the frame buffer configuration file. + */ + fb_nconfig = 0; + while (fgets (lbuf, SZ_LINE, fp) != NULL) { + /* Skip comment lines and blank lines. */ + for (ip=lbuf; *ip == ' ' || *ip == '\t'; ip++) + ; + if (*ip == '\n' || *ip == '#') + continue; + if (!isdigit (*ip)) + continue; + switch (sscanf (ip, "%d%d%d%d", &config,&nframes,&width,&height)) { + case 4: + break; /* normal case */ + case 3: + height = width; /* default to square format */ + break; + default: + fprintf (stderr, "imtool: bad config `%s'\n", ip); + continue; + } + + nframes = max (1, nframes); + width = max (1, width); + height = max (1, height); + + /* Since the frame buffer is stored in a memory pixrect + * (effectively), the line length should be an integral number + * of 16 bit words. + */ + if (width & 1) { + fprintf (stderr, "imtool warning: fb config %d [%d-%dx%d] - ", + config, nframes, width, height); + fprintf (stderr, "frame width should be even, reset to %d\n", + --width); + } + + config = max(1, min(MAX_FBCONFIG, config)) - 1; + fb_config[config].nframes = nframes; + fb_config[config].width = width; + fb_config[config].height = height; + fb_nconfig = max (fb_nconfig, config+1); + } + + fclose (fp); +} + + +/* SET_FBCONFIG -- Setup a frame buffer configuration. + */ +static +set_fbconfig (config, nframes) +int config; +int nframes; +{ + register struct pixrect *pr = get_screen_rect(); + int old_config = fb_config_index; + int old_nframes = fb_nframes; + char text[SZ_LINE]; + + if (config < 0 || config >= fb_nconfig) { + fprintf (stderr, + "imtool: no such frame buffer configuration - %d\n", config+1); + return; + } else if (nframes <= 0) + nframes = fb_config[config].nframes; + + if (init_framebuffers (config, nframes) == -1) { + fprintf (stderr, "restore configuration %d\n", old_config + 1); + if (init_framebuffers (old_config, old_nframes) == -1) { + fprintf (stderr, + "cannot restore frame buffer configuration - imtool dies\n"); + exit (1); + } + } + + if (gio_xsize <= 0 || gio_xsize > Fb_width) + gio_xsize = Fb_width; + if (gio_ysize <= 0 || gio_ysize > (Fb_height + cb_height)) + gio_ysize = Fb_height + cb_height; + + gio_xsize = min (pr->pr_width - TOOL_BORDERWIDTH * 2, gio_xsize); + gio_ysize = min (pr->pr_height + - tool_headerheight ((int)window_get(gio_frame,FRAME_SHOW_LABEL)) + - TOOL_BORDERWIDTH, gio_ysize); + + window_set (gio_canvas, + WIN_WIDTH, gio_xsize, + WIN_HEIGHT, gio_ysize, + 0); + + window_fit (gio_canvas); + window_fit (gio_frame); + + Bpw_get_region_rect (gio_pw, &pw_rect); + pw_rect.r_left = df_p->fb_xoff; + pw_rect.r_top = df_p->fb_yoff; + + sprintf (text, "Frame buffer configuration %d: %d %dx%d frame%c", + fb_config_index + 1, fb_nframes, Fb_width, Fb_height, + fb_nframes > 1 ? 's' : ' '); + + window_set (gio_frame, FRAME_LABEL, text, 0); + panel_set_value (pan_set_maptype, df_p->fb_maptype); + panel_set_value (pan_set_nframes, fb_nframes - 1); +} + + +/* LOAD_RASTER -- Load a rasterfile into the display. + */ +static +load_raster (o_pr, fname) +Pixrect *o_pr; +char *fname; +{ + FILE *fp; + Pixrect *i_pr; + int width, height; + + if ((fp = fopen (fname, "r")) == NULL) + fprintf (stderr, "cannot open rasterfile %s\n", fname); + else { + if (i_pr = pr_load (fp, NULL)) { + width = min (Fb_width, i_pr->pr_width); + height = min (Fb_height, i_pr->pr_height); + pr_rop (o_pr, 0, 0, width, height, PIX_SRC, i_pr, 0, 0); + pr_close (i_pr); + repaint (P_IMAGE|P_COLORBAR|P_GRAPHICS); + } + fclose (fp); + } +} + + +/* SAVE_RASTER -- Save a frame buffer in a file. + */ +static +save_raster (i_pr, fname) +Pixrect *i_pr; +char *fname; +{ + FILE *fp; + + if ((fp = fopen (fname, "w")) == NULL) + fprintf (stderr, "cannot create rasterfile %s\n", fname); + else { + if (pr_dump (i_pr, fp, RMT_NONE, RT_STANDARD, 0) == PIX_ERR) + fprintf (stderr, "error writing rasterfile %s\n", fname); + fclose (fp); + } +} + + +/* CREATE_GIO_CANVAS -- Set up the canvas for the main display window. + */ +static +create_gio_canvas (argc, argv) +int argc; +char **argv; +{ + register char *argp; + register int arg; + char pathname[NGREY]; + struct pixwin *pw; + int name; + + /* Override the builtin defaults with the values given by the user + * on the command line, if any. + */ + for (arg=1; arg <= argc && (argp = argv[arg]) != NULL; arg++) { + if (!strcmp (argp, "-Ws") || !strncmp (argp, "-size", 5)) { + gio_xsize = atoi (argv[++arg]) - (TOOL_BORDERWIDTH * 2); + gio_ysize = atoi (argv[++arg]) - + (tool_headerheight ((int) window_get (gio_frame, + FRAME_SHOW_LABEL)) + TOOL_BORDERWIDTH); + } else if (!strncmp (argp, "-maptype", 4)) { + argp = argv[++arg]; + if (!strncmp (argp, "mono", 1)) + maptype = MONO; + else if (!strncmp (argp, "heat", 1)) + maptype = HEAT; + else if (!strncmp (argp, "ramp1", 1)) + maptype = RAMP1; + else if (!strncmp (argp, "ramp2", 1)) + maptype = RAMP2; + else if (!strncmp (argp, "halley", 1)) + maptype = HALLEY; + else if (!strncmp (argp, "linear", 1)) + maptype = LINEARPS; + else if (!strncmp (argp, "random", 1)) + maptype = RANDOMPS; + else if (!strncmp (argp, "crandom", 1)) + maptype = CRANDOMPS; + else if (!strncmp (argp, "ulut1", 1)) + maptype = ULUT1; + else if (!strncmp (argp, "ulut2", 1)) + maptype = ULUT2; + else + fprintf (stderr, "unknown arg `%s' to -maptype\n", argp); + } else if (!strncmp (argp, "-nocolorbar", 9)) { + cb_height = 0; + show_colorbar = 0; + } else if (!strncmp (argp, "-colorbar", 7)) { + cb_height = SZ_COLORBAR; + show_colorbar = 1; + } else if (!strncmp (argp, "-black", 3)) { + background = CMS_BACKGROUND; + fb_bkgcolor_index = BKG_BLACK; + } else if (!strncmp (argp, "-white", 3)) { + background = 0; + fb_bkgcolor_index = BKG_WHITE; + + } else if (!strncmp (argp, "-rtype", 3)) { + argp = argv[++arg]; + r_type = (argp[0] == 'r'); + } else if (!strncmp (argp, "-rdispose", 3)) { + argp = argv[++arg]; + strcpy (r_dispose, argp); + } else if (!strncmp (argp, "-rfilename", 3)) { + argp = argv[++arg]; + strcpy (r_filename, argp); + } else if (!strncmp (argp, "-ulut1", 6)) { + argp = argv[++arg]; + strcpy (u_lut1, argp); + } else if (!strncmp (argp, "-ulut2", 6)) { + argp = argv[++arg]; + strcpy (u_lut2, argp); + } + } + + /* Open display canvas. The display canvas is never retained at the + * pixwin level since we can easily refresh it from the frame buffer. + */ + gio_canvas = window_create (gio_frame, CANVAS, + WIN_WIDTH, gio_xsize, + WIN_HEIGHT, gio_ysize, + CANVAS_RETAINED, FALSE, + CANVAS_AUTO_CLEAR, FALSE, + CANVAS_REPAINT_PROC, refresh_display, + 0); + if (gio_canvas == NULL) + exit (1); + + /* Initialize the frame and lut parameters and the canvax pixwin + * color map. + */ + pw = (struct pixwin *) window_get (gio_canvas, WIN_PIXWIN); + fb_depth = pw->pw_pixrect->pr_depth; + if (fb_depth < 8) { + fprintf (stderr, "imtool cannot be used on monochrome displays\n"); + exit (1); + } + + white = (1 << fb_depth) - 1; + if ((fb_ngrey = CMS_DATARANGE) > (white + 1)) + fb_ngrey = 1; + init_colormap (pw); + init_colormap (gio_pw = canvas_pixwin (gio_canvas)); + + /* Set input event flags. */ + window_set (gio_canvas, + WIN_CONSUME_PICK_EVENTS, WIN_NO_EVENTS, + WIN_MOUSE_BUTTONS, WIN_UP_EVENTS, LOC_DRAG, LOC_WINEXIT, 0, + WIN_CONSUME_KBD_EVENTS, WIN_NO_EVENTS, + WIN_ASCII_EVENTS, WIN_LEFT_KEYS, WIN_RIGHT_KEYS, + KEY_SETUP, KEY_REMARK, KEY_SNAP, KEY_PCOORDS, KBD_DONE, 0, + 0); + + notify_set_event_func (ev_panner, ev_panner, NOTIFY_SAFE); +} + + +/* CREATE_SETUP_POPUP -- Create the popup menu used to set the terminal + * setup options. + */ +static +create_setup_popup () +{ + extern loadframe_proc(), saveframe_proc(), fitframe_proc(); + extern reset_proc(), iclear_proc(), gclear_proc(); + extern setup_proc(), toggle_graphics(), set_background(); + extern setframe_proc(), blinkenable_proc(), register_proc(); + static Panel_setting set_ofname(), set_rfname(); + static Panel_setting set_rtype(), set_rdispose(), set_rfilename(); + static Panel_setting set_ulut1(), set_ulut2(); + static Panel_setting set_blinklist(), set_zoomslist(); + static panel_set_item(); + + setup_frame = window_create (gio_frame, FRAME, + FRAME_NO_CONFIRM, TRUE, + WIN_X, setup_xoff, + WIN_Y, setup_yoff, + 0); + if (setup_frame == NULL) + exit (1); + setup_panel = window_create (setup_frame, PANEL, 0); + if (setup_panel == NULL) + exit (1); + + panel_create_item (setup_panel, PANEL_MESSAGE, + PANEL_ITEM_X, ATTR_COL(10), + PANEL_ITEM_Y, ATTR_ROW(0), + PANEL_LABEL_STRING, "Image Display Setup and Control", + 0); + + pan_set_nframes = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(1) + 5, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Number of frame buffers: ", + PANEL_CHOICE_STRINGS, FRAME_CHOICES, 0, + PANEL_VALUE, fb_nframes - 1, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_set_maptype = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(2) + 5, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Greyscale mapping: ", + PANEL_CHOICE_STRINGS, "Mono", + "ESO-Heat", + "Ramp1", + "Ramp2", + "Halley", + "Linear-pseudo", + "Random-pseudo", + "Crandom-pseudo", + "User 1", + "User 2", + 0, + PANEL_VALUE, maptype, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_set_ulut1 = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(3) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "User lookup table 1: ", + PANEL_VALUE, u_lut1, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_ulut1, + 0); + + pan_set_ulut2 = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(4) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "User lookup table 2: ", + PANEL_VALUE, u_lut2, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_ulut2, + 0); + + pan_globalcolor = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(5) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Globally manage colortable: ", + PANEL_CHOICE_STRINGS, "No", "Yes", 0, + PANEL_VALUE, global_colortable, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_crandom_rate = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(6) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Rate (sec) for crandom option: ", + PANEL_CHOICE_STRINGS, CRANDOM_CHOICES, 0, + PANEL_VALUE, crandom_blink_rate, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_set_background = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(7) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Background color: ", + PANEL_CHOICE_STRINGS, "white", "black", 0, + PANEL_VALUE, fb_bkgcolor_index, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_snapframetoo = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(8) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Include frame border in imcopy: ", + PANEL_CHOICE_STRINGS, "No", "Yes", 0, + PANEL_VALUE, snap_frame_too, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_show_colorbar = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(9) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Show colorbar: ", + PANEL_CHOICE_STRINGS, "No", "Yes", 0, + PANEL_VALUE, show_colorbar, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_set_marker = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(10) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Cursor marker: ", + PANEL_CHOICE_STRINGS, "None", "Circle", "Cross", "Square", 0, + PANEL_VALUE, marktype, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_blink_rate = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(11) + 8, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Blink rate (sec): ", + PANEL_CHOICE_STRINGS, BLINKRATE_CHOICES, 0, + PANEL_VALUE, blink_rate_index, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + pan_blink_list = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(12) + 11, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Frames to be blinked: ", + PANEL_VALUE, s_blinklist, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_blinklist, + 0); + + pan_zoom_list = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(13) + 11, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Zoom factors: ", + PANEL_VALUE, s_zoomslist, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_zoomslist, + 0); + + strcpy (o_fname, COORDFILE); + pan_set_ofname = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(14) + 11, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Coordinate list output file: ", + PANEL_VALUE, o_fname, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_ofname, + 0); + + pan_set_rfname = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(15) + 11, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Rasterfile name (load/save): ", + PANEL_VALUE, rasterfile, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_rfname, + 0); + + pan_set_rtype = panel_create_item (setup_panel, PANEL_CYCLE, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(16) + 13, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Screendump output type: ", + PANEL_CHOICE_STRINGS, "postscript", "rasterfile", 0, + PANEL_VALUE, r_type, + PANEL_NOTIFY_PROC, panel_set_item, + 0); + + + pan_set_rdispose = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(17) + 13, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Screendump dispose command: ", + PANEL_VALUE, r_dispose, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_rdispose, + 0); + + pan_set_rfilename = panel_create_item (setup_panel, PANEL_TEXT, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(18) + 11, + PANEL_DISPLAY_LEVEL, PANEL_CURRENT, + PANEL_LABEL_STRING, "Screendump output file: ", + PANEL_VALUE, r_filename, + PANEL_VALUE_STORED_LENGTH, SZ_FNAME, + PANEL_VALUE_DISPLAY_LENGTH, SZ_PANTEXT, + PANEL_NOTIFY_PROC, set_rfilename, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(19) + 15, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel,"Register Frames",0,0), + PANEL_NOTIFY_PROC, register_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Fit Window", 0,0), + PANEL_NOTIFY_PROC, fitframe_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Blink", 0,0), + PANEL_NOTIFY_PROC, blinkenable_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Frame", 0,0), + PANEL_NOTIFY_PROC, setframe_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_ITEM_X, ATTR_COL(0), + PANEL_ITEM_Y, ATTR_ROW(20) + 15, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Reset", 0,0), + PANEL_NOTIFY_PROC, reset_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Iclear", 0,0), + PANEL_NOTIFY_PROC, iclear_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Gclear", 0,0), + PANEL_NOTIFY_PROC, gclear_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Load", 0,0), + PANEL_NOTIFY_PROC, loadframe_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "Save", 0,0), + PANEL_NOTIFY_PROC, saveframe_proc, + 0); + + panel_create_item (setup_panel, PANEL_BUTTON, + PANEL_LABEL_IMAGE, + panel_button_image (setup_panel, "DISMISS", 0,0), + PANEL_NOTIFY_PROC, setup_proc, + 0); + + window_fit (setup_panel); + window_fit (setup_frame); +} + + +/* PANEL_SET_ITEM -- Called when an item is seleted in the setup panel to + * set the associated global variable and possibly take some action. + */ +static +panel_set_item (item, value) +Panel_item item; +int value; +{ + if (item == pan_set_nframes) { + set_fbconfig (fb_config_index, value + 1); + } else if (item == pan_set_maptype) { + df_p->fb_maptype = maptype = value; + set_colortable(); + set_transfer_function (gio_pw, df_p->fb_center, df_p->fb_slope); + } else if (item == pan_crandom_rate) { + crandom_blink_rate = value; + } else if (item == pan_set_marker) { + marktype = value; + } else if (item == pan_blink_rate) { + blink_rate_index = value; + } else if (item == pan_set_rtype) { + r_type = value; + } else if (item == pan_globalcolor) { + global_colortable = value; + + } else if (item == pan_set_background) { + /* Set the background color. + */ + if (fb_bkgcolor_index != value) { + register unsigned char *fb, *op; + register int n = Fb_height * Fb_width; + fb = (unsigned char *) mpr_d(df_p->fb_pr)->md_image; + + switch (fb_bkgcolor_index = value) { + case BKG_BLACK: + background = CMS_BACKGROUND; + for (op=fb; --n >= 0; op++) + if (!*op) + *op = background; + break; + case BKG_WHITE: + background = 0; + for (op=fb; --n >= 0; op++) + if (*op == CMS_BACKGROUND) + *op = 0; + break; + } + gclear_proc(); + } + + } else if (item == pan_show_colorbar) { + if (show_colorbar != value) { + struct pixrect *pr = get_screen_rect(); + + show_colorbar = value; + if (show_colorbar) { + cb_height = SZ_COLORBAR; + gio_ysize += cb_height; + gio_ysize = min (Fb_height + cb_height, gio_ysize); + } else { + cb_height = 0; + gio_ysize -= SZ_COLORBAR; + } + + gio_xsize = + min (pr->pr_width - TOOL_BORDERWIDTH * 2, gio_xsize); + gio_ysize = + min (pr->pr_height - + tool_headerheight ((int) window_get (gio_frame, + FRAME_SHOW_LABEL)) - TOOL_BORDERWIDTH, + gio_ysize); + + window_set (gio_canvas, + WIN_WIDTH,gio_xsize, WIN_HEIGHT,gio_ysize, 0); + + window_fit (gio_canvas); + window_fit (gio_frame); + } + + } else if (item == pan_snapframetoo) + snap_frame_too = value; +} + + +/* SET_ZOOMSLIST -- Set the list of zoom factors. + */ +static Panel_setting +set_zoomslist (item, event) +Panel_item item; +Event *event; +{ + register char *ip; + register int i; + + strcpy (s_zoomslist, (char *) panel_get_value (item)); + for (ip=s_zoomslist; isspace (*ip); ip++) + ; + + nzooms = 0; + while (*ip && isdigit (*ip)) { + zooms[nzooms++] = max (1, atoi(ip)); + while (isdigit (*ip)) + ip++; + while (isspace (*ip)) + ip++; + if (nzooms >= MAX_ZOOMS) + break; + } + + return (panel_text_notify (item,event)); +} + + +/* SET_BLINKLIST -- Set the list of frames to be blinked. + */ +static Panel_setting +set_blinklist (item, event) +Panel_item item; +Event *event; +{ + register char *ip; + register int i; + + strcpy (s_blinklist, (char *) panel_get_value (item)); + for (ip=s_blinklist; isspace (*ip); ip++) + ; + + n_blink_frames = 0; + if (strncmp (ip, "all", 3) == 0) { + n_blink_frames = MAX_FRAMES; + for (i=0; i < MAX_FRAMES; i++) + blink_frames[i] = i + 1; + } else { + while (*ip && isdigit (*ip)) { + blink_frames[n_blink_frames++] = atoi(ip); + while (isdigit (*ip)) + ip++; + while (isspace (*ip)) + ip++; + } + } + + return (panel_text_notify (item,event)); +} + + +/* BLINKENABLE_PROC -- Turn frame blink on or off. + */ +static +blinkenable_proc() +{ + blink = !blink; + menu_set (blink_item, MENU_STRING, blink ? "Blink off" : "Blink on", 0); + blink_frame = n_blink_frames - 1; + blink_timer = 0; +} + + +/* REGISTER_PROC -- Register all frames with the current frame. + */ +static +register_proc() +{ + register struct framebuf *fr_p; + register int i; + + for (i=0, fr_p=frames; i < fb_nframes; i++, fr_p++) + if (fr_p != df_p) + set_zoom (fr_p, df_p->fb_xoff, df_p->fb_yoff, df_p->fb_xzoom); +} + + +/* SET_OFNAME -- Set the file name for coordinate output. + */ +static Panel_setting +set_ofname (item, event) +Panel_item item; +Event *event; +{ + char *s; + + s = (char *) panel_get_value (item); + if (strcmp (s, o_fname)) { + strcpy (o_fname, s); + df_p->fb_imageno = 0; + df_p->fb_objno = 1; + window_set (gio_frame, FRAME_LABEL, framelabel(), 0); + } + + return (panel_text_notify (item,event)); +} + + +/* SET_ULUT1 -- Set the file name for user lookup table 1. + */ +static Panel_setting +set_ulut1 (item, event) +Panel_item item; +Event *event; +{ + char *s; + + strcpy (u_lut1, (char *) panel_get_value (item)); + return (panel_text_notify (item,event)); +} + + +/* SET_ULUT2 -- Set the file name for user lookup table 2. + */ +static Panel_setting +set_ulut2 (item, event) +Panel_item item; +Event *event; +{ + char *s; + + strcpy (u_lut2, (char *) panel_get_value (item)); + return (panel_text_notify (item,event)); +} + + +/* SET_RFNAME -- Set the file name for rasterfile load/save. + */ +static Panel_setting +set_rfname (item, event) +Panel_item item; +Event *event; +{ + char *s; + + strcpy (rasterfile, (char *) panel_get_value (item)); + return (panel_text_notify (item,event)); +} + + +/* SET_RDISPOSE -- Set the raster file dispose command. + */ +static Panel_setting +set_rdispose (item, event) +Panel_item item; +Event *event; +{ + char *s; + + strcpy (r_dispose, (char *) panel_get_value (item)); + return (panel_text_notify (item,event)); +} + + +/* SET_RFILENAME -- Set the screendump filename template. + */ +static Panel_setting +set_rfilename (item, event) +Panel_item item; +Event *event; +{ + char *s; + + strcpy (r_filename, (char *) panel_get_value (item)); + return (panel_text_notify (item,event)); +} + + +/* LOADFRAME_PROC -- Load the named rasterfile into the current frame. + */ +static +loadframe_proc() +{ + char fname[SZ_FNAME+1]; + char buf[SZ_FNAME+1]; + + sprintf (buf, rasterfile, df_p->fb_frameno, df_p->fb_imageno); + strcpy (fname, getfname(buf, 0)); + load_raster (df_p->fb_pr, fname); +} + + +/* SAVEFRAME_PROC -- Save the current frame in the named rasterfile. + */ +static +saveframe_proc() +{ + char fname[SZ_FNAME+1]; + char buf[SZ_FNAME+1]; + + sprintf (buf, rasterfile, df_p->fb_frameno, df_p->fb_imageno); + strcpy (fname, getfname(buf, 0)); + save_raster (df_p->fb_pr, fname); +} + + +/* FITFRAME_PROC -- Fit the display window to the current frame buffer size. + */ +static +fitframe_proc() +{ + register struct pixrect *pr = get_screen_rect(); + + gio_xsize = min (pr->pr_width - TOOL_BORDERWIDTH * 2, Fb_width); + gio_ysize = min (pr->pr_height + - tool_headerheight ((int)window_get(gio_frame,FRAME_SHOW_LABEL)) + - TOOL_BORDERWIDTH, + Fb_height + cb_height); + + window_set (gio_canvas, + WIN_WIDTH, gio_xsize, + WIN_HEIGHT, gio_ysize, + 0); + + window_fit (gio_canvas); + window_fit (gio_frame); +} + + +/* GET_SCREEN_RECT -- Determine the size of the workstation screen. + */ +static struct pixrect * +get_screen_rect() +{ + static struct pixrect screen; + struct pixrect *pr; + + if (!screen.pr_width) + if (pr = pr_open ("/dev/fb")) { + screen = *pr; + pr_close (pr); + } else { + screen.pr_width = 1152; + screen.pr_width = 900; + } + + return (&screen); +} + + +/* SETUP_PROC -- Toggle whether or not the setup panel is shown. + */ +static +setup_proc() +{ + if ((int) window_get (setup_frame, WIN_SHOW) == TRUE) { + setup_xoff = (int) window_get (setup_frame, WIN_X, 0); + setup_yoff = (int) window_get (setup_frame, WIN_Y, 0); + window_set (setup_frame, WIN_SHOW, FALSE, 0); + } else { + window_set (setup_frame, + WIN_X, setup_xoff, + WIN_Y, setup_yoff, + 0); + window_set (setup_frame, WIN_SHOW, TRUE, 0); + } +} + + +/* CREATE_FRAME_MENU -- Imtool uses a special frame menu which provides the + * standard frame menu as a submenu. + */ +static +create_frame_menu (frame) +Frame frame; +{ + extern imagecopy_proc(), register_proc(); + extern setup_proc(), setframe_proc(), fitframe_proc(); + extern iclear_proc(), gclear_proc(), blinkenable_proc(); + Menu new_menu, old_menu; + + /* Get the standard frame menu. */ + old_menu = (Menu) window_get (frame, WIN_MENU); + + /* Create the new frame root menu */ + new_menu = menu_create ( + MENU_PULLRIGHT_ITEM, + "Frame", + old_menu, + MENU_ACTION_ITEM, + "Setup", + setup_proc, + MENU_ACTION_ITEM, + "Register", + register_proc, + MENU_ACTION_ITEM, + "Blink on", + blinkenable_proc, + MENU_ACTION_ITEM, + "FitFrame", + fitframe_proc, + MENU_ACTION_ITEM, + "NextFrame", + setframe_proc, + MENU_ACTION_ITEM, + "Gclear", + gclear_proc, + MENU_ACTION_ITEM, + "Iclear", + iclear_proc, + MENU_ACTION_ITEM, + "Imcopy", + imagecopy_proc, + 0); + + blink_item = menu_find (new_menu, MENU_STRING, "Blink on", 0); + + /* Install the new menu. */ + window_set (frame, WIN_MENU, new_menu, 0); +} + + +/* INIT_FRAMEBUFFERS -- Allocate space for the indicated number and size of + * framebuffers, initializing the framebuffer data structures accordingly. + * If at least one frame buffer of the desired size can be allocated we + * consider it a success, but set fb_nframes accordingly. -1 is returned + * if no frames of the desired size can be allocated. + */ +static +init_framebuffers (config, nframes) +int config; /* new frame buffer configuration */ +int nframes; /* desired number of frames */ +{ + register struct framebuf *fb; + register int i; + char *calloc(); + + nframes = min (MAX_FRAMES, nframes); + + /* If we are only changing the number of frames in the current + * configuration, keep the old frames. + */ + if (frames && config == fb_config_index) { + if (nframes == fb_config[config].nframes) { + fb_nframes = nframes; + return (nframes); + + } else if (nframes < fb_config[config].nframes) { + for (i=nframes; i < fb_nframes; i++) + pr_close (frames[i].fb_pr); + fb_config[config].nframes = fb_nframes = nframes; + if (reference_frame > nframes) { + reference_frame = nframes; + rf_p = frames + (reference_frame - 1); + } + if (display_frame > nframes) + set_frame (nframes); + return (nframes); + + } else if (nframes > fb_config[config].nframes) + ; /* fall through and add more frames */ + + } else { + /* Deallocate old frame buffers, if any. */ + if (frames) { + pr_close (cb_pr); + for (i=0; i < fb_nframes; i++) + pr_close (frames[i].fb_pr); + free (frames); + } + + fb_nframes = 0; + frames = (struct framebuf *) calloc (MAX_FRAMES, + sizeof(struct framebuf)); + + df_p = rf_p = frames; + display_frame = reference_frame = 1; + strcpy (o_fname, COORDFILE); + wc_xoff = wc_yoff = 0; + } + + /* Allocate and initialize the new frame buffers. */ + fb_config_index = config; + Fb_width = fb_config[config].width; + Fb_height = fb_config[config].height; + + for (i=fb_nframes; i < nframes; i++) { + fb = frames + i; + fb->fb_pr = mem_create (Fb_width, Fb_height, fb_depth); + if (fb->fb_pr == NULL) { + fprintf (stderr, + "attempt to allocate frame buffer %d (%dx%d) fails\n", + i + 1, Fb_width, Fb_height); + if (i) + break; + else + return (-1); + } else if (!fb_nframes++) { + cb_pr = mem_create (Fb_width, cb_height, fb_depth); + if (pw_rect.r_width) + init_colorbar (pw_rect.r_width); + } + + fb->fb_xoff = 0; + fb->fb_yoff = 0; + fb->fb_xzoom = fb->fb_yzoom = 1; + fb->fb_center = fb_ngrey / 2.0; + fb->fb_slope = (float)white / (float)(fb_ngrey - 1); + fb->fb_maptype = maptype; + fb->fb_objno = 1; + fb->fb_imageno = 0; + fb->fb_frameno = i + 1; + fb->fb_ctran.valid = 0; + fb->fb_ctran.imtitle[0] = '\0'; + strcpy (fb->fb_ctran.format, W_DEFFORMAT); + } + + set_zoom (df_p, 0, 0, 1); + return (fb_config[config].nframes = fb_nframes); +} + + +/* INIT_COLORBAR -- Write the colorbar into the frame buffer. The length of + * the colorbar should correspond to the current width of the display window, + * but must not exceed the width of the frame buffer. + */ +init_colorbar (cb_width) +int cb_width; +{ + register int i; + unsigned char *lp; + Pixrect *pr; + + if (cb_height <= 0) + return; + + if ((pr = mem_create (cb_width, 1, fb_depth)) != NULL) { + lp = (unsigned char *) mpr_d(pr)->md_image; + /* Write colorbar. */ + for (i=0; i < cb_width; i++) + lp[i] = (CMS_DATARANGE-1) * i / (cb_width-1) + + CMS_DATASTART; + for (i=3; i < cb_height; i++) + pr_rop (cb_pr, 0, i, cb_width, 1, PIX_SRC, pr, 0, 0); + + /* Add a border between image and colorbar. */ + for (i=0; i < cb_width; i++) + lp[i] = NGREY-1; + for (i=0; i < 3; i++) + pr_rop (cb_pr, 0, i, cb_width, 1, PIX_SRC, pr, 0, 0); + + for (i=0; i < cb_width; i++) + lp[i] = 0; + for (i=1; i < 2; i++) + pr_rop (cb_pr, 0, i, cb_width, 1, PIX_SRC, pr, 0, 0); + + pr_close (pr); + } +} + + +/* INIT_COLORMAP -- Initialize the IMTOOL color map. + */ +static +init_colormap (pw) +struct pixwin *pw; +{ + register unsigned char *r = red; + register unsigned char *g = green; + register unsigned char *b = blue; + int planes = NGREY-1, i; + + /* Initialize the IMTOOL colormap from the current fullscreen + * colormap, so that the (small) colormap entries of the other + * windows will be preserved, as far as possible. + */ + grab_colormap (r, g, b); + + /* Set a linear transfer function for the main part of the table. */ + for (i=CMS_DATASTART; i <= CMS_DATAEND; i++) + r[i] = g[i] = b[i] = i * (white + 1) / CMS_DATARANGE; + + /* Color table entry for the cursor. */ + r[CMS_CURSOR] = white; + g[CMS_CURSOR] = white; + b[CMS_CURSOR] = white; + + /* Set the background and graphics colors. + */ + i = CMS_BACKGROUND; + r[i] = 0; g[i] = 0; b[i] = 0; i++; /* 202=black */ + + i = CMS_GRAPHICSSTART; + r[i] = 255; g[i] = 255; b[i] = 255; i++; /* 203=white */ + + r[i] = 255; g[i] = 0; b[i] = 0; i++; /* 204=red */ + r[i] = 0; g[i] = 255; b[i] = 0; i++; /* 205=green */ + r[i] = 0; g[i] = 0; b[i] = 255; i++; /* 206=blue */ + r[i] = 255; g[i] = 255; b[i] = 0; i++; /* 207=yellow */ + r[i] = 0; g[i] = 255; b[i] = 255; i++; /* 208=cyan */ + r[i] = 255; g[i] = 0; b[i] = 255; i++; /* 209=magenta */ + r[i] = 255; g[i] = 127; b[i] = 0; i++; /* 210=coral */ + r[i] = 142; g[i] = 35; b[i] = 107; i++; /* 211=maroon */ + r[i] = 204; g[i] = 50; b[i] = 50; i++; /* 212=orange */ + r[i] = 159; g[i] = 159; b[i] = 95; i++; /* 213=khaki */ + r[i] = 219; g[i] = 112; b[i] = 219; i++; /* 214=orchid */ + r[i] = 112; g[i] = 219; b[i] = 219; i++; /* 215=turquoise */ + r[i] = 159; g[i] = 95; b[i] = 159; i++; /* 216=violet */ + r[i] = 216; g[i] = 216; b[i] = 191; i++; /* 217=wheat */ + + pw_setcmsname (pw, CMMAPNAME); + pw_putcolormap (pw, 0, NGREY, r, g, b); + pw_putattributes (pw, &planes); +} + + +/* COMPUTE_TRANSFER_FUNCTION -- Compute the slope and offset of the transfer + * function for the current display frame, given the coordinates of the + * mouse in the frame. + */ +static +compute_transfer_function (event) +Event *event; +{ + float xsize, ysize; + float y, slope; + int neg; + + xsize = pw_rect.r_width; + ysize = pw_rect.r_height; + + /* Compute the slope of the transfer function. */ + y = event_y(event) / ysize * 2.0 - 1.0; + if (neg = (y < 0.0)) + y = -y; + if (y > 0.99) + y = 0.99; + if ((slope = tan (y * M_PI_2)) > white) + slope = white; + + /* Record new transfer function in frame buffer descriptor. */ + df_p->fb_center = event_x(event) / xsize * (fb_ngrey-1); + df_p->fb_slope = neg ? -slope : slope; +} + + +/* SET_TRANSFER_FUNCTION -- Load the color map as necessary to implement the + * given linear transfer function. + */ +static +set_transfer_function (pw, center, slope) +struct pixwin *pw; /* reference pixwin */ +float center; /* greyscale value at half intensity */ +float slope; /* delta-intensity per greyscale unit */ +{ + register int i; + register float z, zmin, zmax; + unsigned char o_red[NGREY], o_green[NGREY], o_blue[NGREY]; + unsigned char *p_r, *p_g, *p_b; + + if (center < CMS_DATASTART) + center = CMS_DATASTART; + else if (center > CMS_DATAEND) + center = CMS_DATAEND; + + zmin = 0.0; + zmax = white; + + z = white / 2; + for (i=center; i <= CMS_DATAEND; i++) { + o_red[i] = m_red[(unsigned char)(int)z]; + o_green[i] = m_green[(unsigned char)(int)z]; + o_blue[i] = m_blue[(unsigned char)(int)z]; + z += slope; + if (z <= zmin) + z = zmin; + else if (z >= zmax) + z = zmax; + } + + z = white / 2; + for (i=center; i >= CMS_DATASTART; i--) { + o_red[i] = m_red[(unsigned char)(int)z]; + o_green[i] = m_green[(unsigned char)(int)z]; + o_blue[i] = m_blue[(unsigned char)(int)z]; + z -= slope; + if (z <= zmin) + z = zmin; + else if (z >= zmax) + z = zmax; + } + + p_r = &o_red[CMS_DATASTART]; + p_g = &o_green[CMS_DATASTART]; + p_b = &o_blue[CMS_DATASTART]; + + /*pw_putcolormap (pw, CMS_DATASTART, CMS_DATARANGE, p_r, p_g, p_b);*/ + + bcopy (p_r, &red[CMS_DATASTART], CMS_DATARANGE); + bcopy (p_g, &green[CMS_DATASTART], CMS_DATARANGE); + bcopy (p_b, &blue[CMS_DATASTART], CMS_DATARANGE); + + /* Reset the full 8 bit colormap for the pixwin, to pick up any + * changes made in the unused regions for other windows, picked up + * by edit_colortable below. + */ + pw_putcolormap (pw, 0, NGREY, red, green, blue); +} + + +/* SET_COLORTABLE -- Set up the RGB lookup tables used to map the windowed + * monochrome output of a frame buffer into the hardware colormap. + */ +static Notify_value +set_colortable() +{ + register int v, vsat, step, i; + static int seed = 0; + int knot[7]; + + vsat = NGREY - 1; + step = NGREY / 6; + for (i=0; i < 7; i++) + knot[i] = i * step; + knot[6] = vsat; + + switch (df_p->fb_maptype) { + case MONO: + for (i=0; i < NGREY; i++) + m_red[i] = m_green[i] = m_blue[i] = i; + break; + + case HEAT: + for (i=0; i < NGREY; i++) { + m_red[i] = heat.hue[i].red * (NGREY - 1); + m_green[i] = heat.hue[i].green * (NGREY - 1); + m_blue[i] = heat.hue[i].blue * (NGREY - 1); + } + break; + + case RAMP1: + for (i=0; i < NGREY; i++) { + m_red[i] = heat.hue[i].red * NGREY; + m_green[i] = heat.hue[i].green * NGREY; + m_blue[i] = heat.hue[i].blue * NGREY; + } + break; + + case RAMP2: + for (i=0; i < NGREY; i++) { + m_red[i] = heat.hue[i].red * ((NGREY - 1) * 2); + m_green[i] = heat.hue[i].green * ((NGREY - 1) * 2); + m_blue[i] = heat.hue[i].blue * ((NGREY - 1) * 2); + } + break; + + case HALLEY: + for (i=0; i < NGREY; i++) { + m_red[i] = halley.hue[i].red * (NGREY - 1); + m_green[i] = halley.hue[i].green * (NGREY - 1); + m_blue[i] = halley.hue[i].blue * (NGREY - 1); + } + break; + + case ULUT1: + case ULUT2: + { struct lut user; + struct triplet *p; + int i, j; + FILE *fp; + char *s; + + s = (df_p->fb_maptype == ULUT1) ? u_lut1 : u_lut2; + if ((fp = fopen (getfname(s,0), "r")) == NULL) { + fprintf (stderr, "cannot open %s\n", s); + return; + } + + for (user.lutlen=0; user.lutlen < NGREY; user.lutlen++) { + p = &user.hue[user.lutlen]; + if (fscanf (fp, " %f %f %f", + &p->red, &p->green, &p->blue) == EOF) + break; + } + + for (i=0; i < NGREY; i++) { + j = max(0, min(NGREY-1, (i * user.lutlen / NGREY))); + m_red[i] = user.hue[j].red * (NGREY - 1); + m_green[i] = user.hue[j].green * (NGREY - 1); + m_blue[i] = user.hue[j].blue * (NGREY - 1); + } + + fclose (fp); + } + break; + + case LINEARPS: + for (i=0; i < NGREY; i++) + m_red[i] = m_green[i] = m_blue[i] = 0; + + for (i=knot[0]; i <= knot[1]; i++) + m_blue[i] = vsat * (i - knot[0]) / step; + for (i=knot[1]; i <= knot[2]; i++) + m_blue[i] = vsat; + for (i=knot[2]; i <= knot[3]; i++) + m_blue[i] = vsat * (knot[3] - i) / step; + + for (i=knot[1]; i <= knot[2]; i++) + m_green[i] = vsat * (i - knot[1]) / step; + for (i=knot[2]; i <= knot[4]; i++) + m_green[i] = vsat; + for (i=knot[4]; i <= knot[5]; i++) + m_green[i] = vsat * (knot[5] - i) / step; + + for (i=knot[3]; i <= knot[4]; i++) + m_red[i] = vsat * (i - knot[3]) / step; + for (i=knot[4]; i <= knot[6]; i++) + m_red[i] = vsat; + + for (i=knot[5]; i <= knot[6]; i++) { + if ((v = vsat * (i - knot[5]) / step) > vsat) + v = vsat; + m_green[i] = m_blue[i] = v; + } + break; + + case CRANDOMPS: + set_transfer_function (gio_pw, df_p->fb_center, df_p->fb_slope); + imt_pause (cr_msec[crandom_blink_rate], set_colortable); + /* fall through */ + + case RANDOMPS: + if (!seed) + seed = time(0); + srand (seed++); + for (i=0; i < NGREY; i++) { + m_red[i] = ((rand() >> 4) % NGREY); + m_green[i] = ((rand() >> 4) % NGREY); + m_blue[i] = ((rand() >> 4) % NGREY); + } + break; + } +} + + +/* GRAB_COLORMAP -- Read the current physical full screen colormap. + */ +static +grab_colormap (red, green, blue) +unsigned char red[], green[], blue[]; +{ + struct pixrect *screen; + + if (window_open) { + screen = pr_open ("/dev/fb"); + pr_getcolormap (screen, 0, NGREY, red, green, blue); + pr_close (screen); + } +} + + +/* IMTOOL_CLOCK -- The main imtool clock. + */ +static +imtool_clock (client, event, arg) +Notify_client client; +Notify_event event; +Notify_arg arg; +{ + static int delay=0, interval=0, toggle=0; + Cursor cursor; + int frame, n; + + /* Blink cursor (variable rate). */ + cursor = window_get (gio_canvas, WIN_CURSOR); + toggle = !toggle; + if (reading_imcursor) { + cursor_set (cursor, + CURSOR_OP, toggle + ? PIX_NOT(PIX_SRC) & PIX_DST + : PIX_SRC | PIX_DST | PIX_COLOR(NGREY-1), + 0); + } else { + cursor_set (cursor, + CURSOR_CROSSHAIR_COLOR, + toggle ? CMS_BACKGROUND : CMS_CURSOR, + 0); + } + window_set (gio_canvas, WIN_CURSOR, cursor, 0); + + /* Things that happen at a fixed interval. */ + if ((delay += interval) >= CLOCK_INTERVAL) { + /* Keep imtool visible (if window open). */ + edit_colormap(); + + /* Frame blink. The frames in the blink frame list do not have to + * exist; if not, then advance through the list until either a valid + * frame is found, or the list has been traversed once. + */ + if (blink && n_blink_frames > 0 && state != WINDOW && window_open) { + if (--blink_timer <= 0) { + for (n=n_blink_frames; --n >= 0; ) { + if (++blink_frame >= n_blink_frames) + blink_frame = 0; + frame = blink_frames[blink_frame]; + if (frame >= 1 && frame <= fb_nframes) { + set_frame (frame); + if (display_coords && state == TRACK_CURSOR) + update_coords (NULL); + break; + } + } + blink_timer = blink_rate[blink_rate_index]; + } + } + + delay = 0; + } + + interval = reading_imcursor ? CLOCK_INTERVAL/4 : CLOCK_INTERVAL; + imt_pause (interval, imtool_clock); +} + + +/* EDIT_COLORMAP -- Overwrite the portion of the full screen colormap used + * by the display server. This must be done in such a way that changes to + * the region of the screen colortable used by other windows are preserved. + */ +static +edit_colormap() +{ + struct pixrect *screen; + unsigned char r[NGREY], g[NGREY], b[NGREY]; + + if (state != WINDOW && window_open) { + /* Edit the physical colortable. */ + screen = pr_open ("/dev/fb"); + pr_getcolormap (screen, 0, NGREY, r, g, b); + + /* Make the cursor blink between black and white for better vis. + * (>> now done with set_cursor in imtool_clock()) + if (green[CMS_CURSOR] == white) { + red[CMS_CURSOR] = black; + green[CMS_CURSOR] = black; + blue[CMS_CURSOR] = black; + } else { + red[CMS_CURSOR] = white; + green[CMS_CURSOR] = white; + blue[CMS_CURSOR] = white; + } + */ + + bcopy (&red[CMS_FIRST], &r[CMS_FIRST], CMS_NGREY); + bcopy (&green[CMS_FIRST], &g[CMS_FIRST], CMS_NGREY); + bcopy (&blue[CMS_FIRST], &b[CMS_FIRST], CMS_NGREY); + + pw_putcolormap (gio_pw, 0, NGREY, r, g, b); + if (global_colortable) + pr_putcolormap (screen, 0, NGREY, r, g, b); + pr_close (screen); + + /* Update the canvas pixwin colortable. */ + bcopy (r, red, NGREY); + bcopy (g, green, NGREY); + bcopy (b, blue, NGREY); + } +} + + +/* SHOW_COLORMAP -- Print the contents of the color map for a pixwin. + */ +static +show_colormap (pw, first, last) +struct pixwin *pw; +int first, last; +{ + unsigned char r[NGREY], g[NGREY], b[NGREY]; + char cmsname[CMS_NAMESIZE]; + int i, n; + + pw_getcmsname (pw, cmsname); + pw_getcolormap (pw, 0, NGREY, r, g, b); + + printf ("color map segment = '%s'\n", cmsname); + for (i=first, n=0; i <= last; i++) { + printf ("%3d %3d %3d", r[i], g[i], b[i]); + printf ((++n % 5) ? " " : "\n"); + } + printf ("\n"); +} + + +/* LOAD_TESTPATTERN -- Load a test pattern into the reference frame buffer. + */ +static +load_testpattern (type) +int type; /* pattern type desired */ +{ + register unsigned char *line; + register int i, j, color; + unsigned char *fb, *oline; + + fb = (unsigned char *) mpr_d(df_p->fb_pr)->md_image; + + switch (type) { + case 0: + /* Compute first line. */ + oline = line = fb; + for (i=0, color=0; i < Fb_width; i++) + if (((i+16) % 32) == 0) { + line[i] = 0; + color = ((i+j) % CMS_DATARANGE) / 32 * 32; + } else + line[i] = color; + + /* Compute remaining lines. */ + for (j=1; j < Fb_height; j++) { + line = fb + j * Fb_width; + if (((j+16) % 32) == 0) { + for (i=0; i < Fb_width; i++) + line[i] = 0; + if (++j >= Fb_height) + break; + line = fb + j * Fb_width; + color = (j % CMS_DATARANGE) / 32 * 32; + for (i=0; i < Fb_width; i++) + if (((i+16) % 32) == 0) { + line[i] = 0; + color = ((i+j) % CMS_DATARANGE) / 32 * 32; + } else + line[i] = color; + oline = line; + } else + bcopy (oline, line, Fb_width); + } + break; + + case 1: + for (j=1; j < Fb_height; j++) { + line = fb + j * Fb_width; + for (i=0; i < Fb_width; i++) + line[i] = (i % CMS_DATARANGE); + } + break; + + case 2: + for (j=1; j < Fb_height; j++) { + line = fb + j * Fb_width; + for (i=0; i < Fb_width; i++) + line[i] = ((i+j) % CMS_DATARANGE); + } + break; + } +} + + +/* For the moment we take an IIS model 70 command/data stream as input; this + * is used to load images into the image display. This is a kludge interface + * for the prototype, convenient since the high level software is written for + * the IIS. + */ +#define MEMORY 01 /* frame buffer i/o */ +#define LUT 02 /* lut i/o */ +#define FEEDBACK 05 /* used for frame clears */ +#define IMCURSOR 020 /* logical image cursor */ +#define WCS 021 /* used to set WCS */ + +#define SZ_IMCURVAL 160 +#define PACKED 0040000 +#define COMMAND 0100000 +#define IIS_READ 0100000 +#define IMC_SAMPLE 0040000 +#define IMT_FBCONFIG 077 +#define XYMASK 077777 + +struct iism70 { + short tid; + short thingct; + short subunit; + short checksum; + short x, y, z; + short t; +}; + +/* EV_CMDINPUT -- Called when command or data input has arrived via the + * pseudodevice input stream from some applications process. + */ +static Notify_value +ev_cmdinput (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + register unsigned char *cp; + register int sum, i; + register short *p; + int ndatabytes, nbytes, n, ntrys=0; + static int errmsg=0, bswap=0; + struct iism70 iis; + char buf[SZ_FIFOBUF]; + int fb_index; + + /* Get the IIS header. */ + if (read (datain, (char *)&iis, sizeof(iis)) < sizeof(iis)) { + fprintf (stderr, "imtool: command input read error\n"); + return (NOTIFY_DONE); + } else if (bswap) + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + + /* Verify the checksum. If it fails swap the bytes and try again. + */ + for (;;) { + for (i=0, sum=0, p=(short *)&iis; i < 8; i++) + sum += *p++; + if ((sum & 0177777) == 0177777) + break; + + if (ntrys++) { + if (!errmsg++) { + fprintf (stderr, "imtool: bad data header checksum\n"); + if (bswap) + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + fprintf (stderr, "noswap:"); + for (i=0, p=(short *)&iis; i < 8; i++) + fprintf (stderr, " %6o", p[i]); + fprintf (stderr, "\n"); + + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + fprintf (stderr, " swap:"); + for (i=0, p=(short *)&iis; i < 8; i++) + fprintf (stderr, " %6o", p[i]); + fprintf (stderr, "\n"); + } + break; + + } else { + bswap2 ((char *)&iis, (char *)&iis, sizeof(iis)); + bswap = !bswap; + } + } + + ndatabytes = -iis.thingct; + if (!(iis.tid & PACKED)) + ndatabytes *= 2; + + switch (iis.subunit & 077) { + case FEEDBACK: + /* The feedback unit is used only to clear a frame. + */ + set_reference_frame (decode_frameno (iis.z & 07777)); + erase (rf_p); + break; + + case LUT: + /* Data mode writes to the frame lookup tables are not implemented. + * A command mode write to the LUT subunit is used to connect + * image memories up to the RGB channels, i.e., to select the frame + * to be displayed. We ignore any attempt to assign multiple + * frames to multiple color channels, and just do a simple frame + * select. + */ + if (iis.subunit & COMMAND) { + int frame, z, n; + short x[14]; + + if (read (datain, (char *)x, ndatabytes) == ndatabytes) { + if (bswap) + bswap2 ((char *)x, (char *)x, ndatabytes); + + z = x[0]; + if (!z) z = 1; + for (n=0; !(z & 1); z >>= 1) + n++; + + frame = max (1, n + 1); + if (frame > fb_nframes) { + if (frame < MAX_FRAMES) + set_fbconfig (fb_config_index, frame); + else { + fprintf (stderr, "imtool warning: "); + fprintf (stderr, + "attempt to display nonexistent frame %d\n", frame); + frame = fb_nframes - 1; + } + } + + set_frame (frame); + return (NOTIFY_DONE); + } + } + + case MEMORY: + /* Load data into the frame buffer. Data is assumed to be byte + * packed. + */ + if (iis.tid & IIS_READ) { + /* Read from the display. + */ + unsigned char *fb, *ip; + int nbytes, nleft, n, x, y; + long starttime; + + /* Get the frame to be read from. */ + set_reference_frame (decode_frameno (iis.z & 07777)); + + fb = (unsigned char *) mpr_d(rf_p->fb_pr)->md_image; + nbytes = ndatabytes; + x = iis.x & XYMASK; + y = iis.y & XYMASK; + + ip = max (fb, min (fb + Fb_width * Fb_height - nbytes, + fb + y * Fb_width + x)); + if (ip != fb + y * Fb_width + x) { + fprintf (stderr, + "imtool: attempted read out of bounds on framebuf\n"); + fprintf (stderr, + "read %d bytes at [%d,%d]\n", nbytes, x, y); + } + + /* Return the data from the frame buffer. */ + starttime = time(0); + for (nleft = nbytes; nleft > 0; nleft -= n) { + n = (nleft < SZ_FIFOBUF) ? nleft : SZ_FIFOBUF; + if ((n = write (dataout, ip, n)) <= 0) { + if (n < 0 || (time(0) - starttime > IO_TIMEOUT)) { + fprintf (stderr, "IMTOOL: timeout on write\n"); + break; + } + } else + ip += n; + } + + return (NOTIFY_DONE); + + } else { + /* Write to the display. + */ + unsigned char *fb, *op; + int nbytes, nleft, n, x, y; + long starttime; + + /* Get the frame to be written into (encoded with a bit for + * each frame, 01 is frame 1, 02 is frame 2, 04 is frame 3, + * and so on). + */ + set_reference_frame (decode_frameno (iis.z & 07777)); + + /* Get a pointer into the frame buffer where the data will + * be put. + */ + fb = (unsigned char *) mpr_d(rf_p->fb_pr)->md_image; + nbytes = ndatabytes; + x = iis.x & XYMASK; + y = iis.y & XYMASK; + + op = max (fb, min (fb + Fb_width * Fb_height - nbytes, + fb + y * Fb_width + x)); + if (op != fb + y * Fb_width + x) { + fprintf (stderr, + "imtool: attempted write out of bounds on framebuf\n"); + fprintf (stderr, + "write %d bytes to [%d,%d]\n", nbytes, x, y); + } + + /* Read the data into the frame buffer. + */ + starttime = time(0); + for (nleft = nbytes; nleft > 0; nleft -= n) { + n = (nleft < SZ_FIFOBUF) ? nleft : SZ_FIFOBUF; + if ((n = read (datain, op, n)) <= 0) { + if (n < 0 || (time(0) - starttime > IO_TIMEOUT)) + break; + } else { + /* Set any zeroed pixels to the background color, + * if a special background color is specified. + */ + if (background) + for (cp=op, i=n; --i >= 0; cp++) + if (!*cp) + *cp = background; + op += n; + } + } + + /* Refresh the display, if the current display frame is the + * same as the reference frame. + */ + if (rf_p == df_p) { + BRect fb_r, pw_r; + + fb_r.r_left = x * zoom; + fb_r.r_top = y * zoom; + fb_r.r_width = min (nbytes * zoom, fb_width); + fb_r.r_height = ((nbytes*zoom*zoom + fb_width-1)/fb_width); + + Bpw_get_region_rect (gio_pw, &pw_rect); + Bpw_lock (gio_pw, &pw_rect); + + pw_rect.r_left = df_p->fb_xoff; + pw_rect.r_top = df_p->fb_yoff; + + if (maprect (&fb_rect, &fb_r, &pw_rect, &pw_r)) + if (maprect (&pw_rect, &pw_r, &fb_rect, &fb_r)) { + ds_write (gio_pw, + pw_r.r_left, pw_r.r_top, + pw_r.r_width, pw_r.r_height, + PIX_SRC | PIX_COLOR(NGREY-1), + df_p->fb_pr, fb_r.r_left, fb_r.r_top); + + if (pw_r.r_top + pw_r.r_height >= pw_rect.r_height + - cb_height) + put_colorbar(); + } + + Bpw_unlock (gio_pw); + } + + return (NOTIFY_DONE); + } + break; + + case WCS: + /* Read or write the WCS for a frame. The frame number to + * which the WCS applies is passed in Z and the frame buffer + * configuration in T. The client changes the frame buffer + * configuration in a WCS set. The WCS text follows the header + * as byte packed ASCII data. + */ + if (iis.tid & IIS_READ) { + /* Return the WCS for the referenced frame. + */ + char emsg[SZ_FNAME]; + char *text; + int frame; + + frame = decode_frameno (iis.z & 07777); + if (frame > fb_nframes) + strcpy (text=emsg, "[NOSUCHFRAME]\n"); + else { + set_reference_frame (frame); + text = wcsbuf[reference_frame-1]; + } + + write (dataout, text, SZ_WCSBUF); + + } else { + /* Set the WCS for the referenced frame. + */ + char buf[1024]; + int fb_config, frame; + + frame = decode_frameno (iis.z & 07777); + if (frame > fb_nframes) + if (frame < MAX_FRAMES) + set_fbconfig (fb_config_index, frame); + + set_reference_frame (frame); + if ((fb_config = iis.t & 077) != fb_config_index) + set_fbconfig (fb_config, reference_frame); + + /* Read in and set up the WCS. */ + if (read (datain, buf, ndatabytes) == ndatabytes) + strncpy (wcsbuf[reference_frame-1], buf, SZ_WCSBUF); + + strcpy (rf_p->fb_ctran.format, W_DEFFORMAT); + rf_p->fb_ctran.imtitle[0] = '\0'; + rf_p->fb_ctran.valid = 0; + rf_p->fb_imageno++; + rf_p->fb_objno = 1; + + wcs_update (rf_p); + if (rf_p == df_p) + window_set (gio_frame, FRAME_LABEL, framelabel(), 0); + } + + return (NOTIFY_DONE); + break; + + case IMCURSOR: + /* Read or write the logical image cursor. This is an extension + * added to provide a high level cursor read facility; this is + * not the same as a low level access to the IIS cursor subunit. + * Cursor reads may be either nonblocking (immediate) or blocking, + * using the keyboard or mouse to terminate the read, and + * coordinates may be returned in either image (world) or frame + * buffer pixel coordinates. + */ + if (iis.tid & IIS_READ) { + /* Read the logical image cursor. In the case of a blocking + * read all we do is initiate a cursor read; completion occurs + * when the user hits a key or button. + */ + if (iis.tid & IMC_SAMPLE) { + /* Sample the cursor position. */ + register struct ctran *ct; + int wcs = iis.z; + int sx, sy; + float wx, wy; + + wx = sx = last_sx + pw_rect.r_left; + wy = sy = last_sy + pw_rect.r_top; + + if (wcs) { + ct = wcs_update (df_p); + if (ct->valid) { + if (abs(ct->a) > .001) + wx = ct->a * sx + ct->c * sy + ct->tx; + if (abs(ct->d) > .001) + wy = ct->b * sx + ct->d * sy + ct->ty; + } + } + + /* Return the cursor value on the output datastream encoded + * in a fixed size ascii buffer. + */ + gio_retcursorval (wx, wy, display_frame*100+wcs, 0, ""); + + } else { + /* Initiate a user triggered cursor read. */ + gio_readcursor (iis.z); + } + + } else { + /* Write (set) the logical image cursor position. */ + register struct ctran *ct; + int sx = iis.x, sy = iis.y; + float wx = sx, wy = sy; + int wcs = iis.z; + + if (wcs) { + ct = wcs_update (df_p); + if (ct->valid) { + if (abs(ct->a) > .001) + sx = (wx - ct->tx) / ct->a; + if (abs(ct->d) > .001) + sy = (wy - ct->ty) / ct->d; + } + } + + gio_setcursorpos (sx - pw_rect.r_left, sy - pw_rect.r_top); + } + + return (NOTIFY_DONE); + break; + + default: + /* Ignore unsupported command input. + */ + break; + } + + /* Discard any data following the header. */ + if (!(iis.tid & IIS_READ)) + for (nbytes = ndatabytes; nbytes > 0; nbytes -= n) { + n = (nbytes < SZ_FIFOBUF) ? nbytes : SZ_FIFOBUF; + if ((n = read (datain, buf, n)) <= 0) + break; + } + + return (NOTIFY_DONE); +} + + +/* SET_REFERENCE_FRAME -- Set reference frame. If the frame referenced is + * greater than the current number of frames, attempt to increase the number + * of frames. + */ +static +set_reference_frame (n) +register int n; +{ + reference_frame = max (1, n); + if (reference_frame > fb_nframes) { + if (reference_frame < MAX_FRAMES) + set_fbconfig (fb_config_index, reference_frame); + else { + fprintf (stderr, "imtool warning: "); + fprintf (stderr, + "attempt to reference nonexistent frame %d\n", + reference_frame); + reference_frame = fb_nframes; + } + } + + rf_p = frames + (reference_frame - 1); +} + + +/* DECODE_FRAMENO -- Decode encoded IIS register frame number. + */ +static +decode_frameno (z) +register int z; +{ + register int n; + + /* Get the frame number, encoded with a bit for each frame, 01 is + * frame 1, 02 is frame 2, 04 is frame 3, and so on. + */ + if (!z) z = 1; + for (n=0; !(z & 1); z >>= 1) + n++; + + return (max (1, n + 1)); +} + + +/* BSWAP2 - Move bytes from array "a" to array "b", swapping successive + * pairs of bytes. The two arrays may be the same but may not be offset + * and overlapping. + */ +static +bswap2 (a, b, nbytes) +char *a, *b; /* input array */ +int nbytes; /* number of bytes to swap */ +{ + register char *ip=a, *op=b, *otop; + register unsigned temp; + + /* Swap successive pairs of bytes. + */ + for (otop = op + (nbytes & ~1); op < otop; ) { + temp = *ip++; + *op++ = *ip++; + *op++ = temp; + } + + /* If there is an odd byte left, move it to the output array. + */ + if (nbytes & 1) + *op = *ip; +} + + +/* Cursor and marker pixrects. + */ +static short p_imcursor[] = { +#include "imtool.cursor" +}; +static short p_imcross[] = { +#include "imtool.cross" +}; +static short p_imsquare[] = { +#include "imtool.square" +}; +mpr_static (old_cursor, 16, 16, 1, NULL); +mpr_static (pr_cursor, 16, 16, 1, p_imcursor); +mpr_static (pr_cross, 16, 16, 1, p_imcross); +mpr_static (pr_square, 16, 16, 1, p_imsquare); +static struct pixrect *marker[] = { NULL, &pr_cursor, &pr_cross, &pr_square }; + +/* GIO_READCURSOR -- Initiate an image cursor read. Save the current + * mouse coordinates if outside the imtool window, restore the mouse to the + * imtool window, and change the cursor shape to indicate that a cursor read + * is in progress. May be called while a cursor read is already in progress + * to reset the cursor-read cursor pixrect. + */ +static +gio_readcursor (wcs) +int wcs; +{ + Cursor cursor = window_get (gio_canvas, WIN_CURSOR); + + if (!reading_imcursor) { + /* Save cursor pixrect for later restore. */ + old_cursor = *((Pixrect *) cursor_get (cursor, CURSOR_IMAGE)); + + /* Save the absolute mouse position so that we can restore it when + * the cursor read is completed. Restore the mouse to the most + * recent position in the IMTOOL window. + */ + get_absmousepos (gio_frame_fd, &save_sx, &save_sy); + gio_setcursorpos (last_sx, last_sy); + + reading_imcursor++; + imcursor_wcs = wcs; + } + + /* Change the cursor shape while the cursor read is in progress. */ + cursor_set (cursor, + CURSOR_IMAGE, &pr_cursor, + CURSOR_SHOW_CURSOR, TRUE, + CURSOR_SHOW_CROSSHAIRS, FALSE, + CURSOR_OP, PIX_NOT(PIX_SRC) & PIX_DST | PIX_COLOR(CMS_CURSOR), + CURSOR_XHOT, 8, + CURSOR_YHOT, 8, + 0); + window_set (gio_canvas, WIN_CURSOR, cursor, 0); +} + + +/* GIO_RESTORECURSOR -- Restore the original cursor. + */ +static +gio_restorecursor() +{ + if (reading_imcursor) { + Cursor cursor; + + /* Restore the mouse position to whatever it was before IMTOOL + * grabbed the mouse for the cursor read. + */ + set_absmousepos (gio_frame_fd, save_sx, save_sy); + + /* Restore the default IMTOOL cursor shape. */ + cursor = window_get (gio_canvas, WIN_CURSOR); + cursor_set (cursor, + CURSOR_IMAGE, &old_cursor, + CURSOR_SHOW_CURSOR, FALSE, + CURSOR_SHOW_CROSSHAIRS, (cursor_show == CURSOR_ON), + 0); + window_set (gio_canvas, WIN_CURSOR, cursor, 0); + + reading_imcursor = 0; + } +} + + +/* GIO_RETCURSORVAL -- Return the cursor value on the output datastream to + * the client which requested the cursor read. + */ +static +gio_retcursorval (wx, wy, wcs, key, strval) +float wx, wy; /* cursor coordinates */ +int wcs; /* encoded WCS value */ +int key; /* keystroke used as trigger */ +char *strval; /* optional string value */ +{ + char curval[SZ_IMCURVAL]; + char keystr[20]; + + /* Encode the cursor value. */ + if (key == EOF) + sprintf (curval, "EOF\n"); + else { + if (isprint (key) && !isspace(key)) { + keystr[0] = key; + keystr[1] = '\0'; + } else + sprintf (keystr, "\\%03o", key); + + sprintf (curval, "%10.3f %10.3f %d %s %s\n", + wx, wy, wcs, keystr, strval); + } + + /* Send it to the client program. */ + write (dataout, curval, sizeof(curval)); +} + + +/* EV_GIOFRAME -- GIO frame event handler. + */ +static Notify_value +ev_gioframe (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + Notify_value value; + + value = notify_next_event_func (frame, event, arg, type); + window_open = (((int) window_get (gio_frame, FRAME_CLOSED)) == 0); + + return (value); +} + + +/* EV_GIOINPUT -- GIO input event handler. + */ +static Notify_value +ev_gioinput (frame, event, arg, type) +Frame frame; +Event *event; +Notify_arg arg; +Notify_event_type type; +{ + register int key; + Notify_value value; + static float xsize, ysize; + BRect rect; + char ch; + + key = event_id (event); + + /* The following is to attempt to restore the image greyscale in the + * global color map, after the color map has been clobbered by the + * window manager when the mouse is moved to some other window. + */ + if (key == KBD_DONE || key == LOC_WINEXIT) { + edit_colormap(); + return (NOTIFY_DONE); + } + + /* Let frame operate upon the event. */ + if ((int)type != PANNER_EVENT) + value = notify_next_event_func (frame, event, arg, type); + + switch (key) { + case WIN_RESIZE: + Bpw_get_region_rect (gio_pw, &pw_rect); + pw_rect.r_left = df_p->fb_xoff = + max(0, min(fb_rect.r_width - pw_rect.r_width, df_p->fb_xoff)); + pw_rect.r_top = df_p->fb_yoff = + max(0, min(fb_rect.r_height - pw_rect.r_height, df_p->fb_yoff)); + + gio_xsize = pw_rect.r_width; + gio_ysize = pw_rect.r_height; + init_colorbar (pw_rect.r_width); + + wc_xoff = wc_yoff = 0; + if (display_coords && state == TRACK_CURSOR) + update_coords (event); + break; + + case KEY_SNAP: + /* Imcopy. */ + imagecopy_proc(); + break; + + case KEY_PCOORDS: + /* Enable/disable continuous display of the cursor coordinates. */ + toggle_displaycoords (event); + break; + + case KEY_SETUP: + /* Toggle display of the setup panel. */ + setup_proc(); + break; + + case KEY_REMARK: + /* Remark a list of objects. */ + if (event_is_down(event)) { + char fname[SZ_FNAME]; + + wcs_update (df_p); + o_revtext = !o_revtext; + sprintf (fname, o_fname, df_p->fb_frameno, df_p->fb_imageno); + strcpy (fname, getfname(fname, 0)); + remark_objects (fname); + } + break; + + case MS_RIGHT: + if (event_is_down(event)) { + last_sx = last_bx = event_x(event); + last_sy = last_by = event_y(event); + } + + /* If the cursor is moved while the right mouse button is + * depressed the image is windowed. If the control key is also + * depressed the cursor is used to roam about in the frame buffer. + */ + if (state == TRACK_CURSOR && event_is_down(event)) { + if (event_ctrl_is_down (event)) + state = ROAM; + else + state = WINDOW; + xsize = pw_rect.r_width; + ysize = pw_rect.r_height; + if (state == WINDOW) { + switch (df_p->fb_maptype) { + case MONO: + case HEAT: + case RAMP1: + case RAMP2: + case HALLEY: + case LINEARPS: + case ULUT1: + case ULUT2: + compute_transfer_function (event); + break; + case RANDOMPS: + case CRANDOMPS: + set_colortable(); + break; + } + set_transfer_function (gio_pw, + df_p->fb_center, df_p->fb_slope); + } + } else if (state != TRACK_CURSOR && event_is_up(event)) + state = TRACK_CURSOR; + break; + + case LOC_DRAG: + last_sx = event_x (event); + last_sy = event_y (event); + + if (panning) + p_cursor_setback--; + if (state == WINDOW) { + compute_transfer_function (event); + set_transfer_function (gio_pw, df_p->fb_center, df_p->fb_slope); + } + break; + + case LOC_MOVE: + last_sx = event_x (event); + last_sy = event_y (event); + + if (panning) + p_cursor_setback--; + if (display_coords && state == TRACK_CURSOR) + update_coords (event); + break; + + case MS_LEFT: + last_sx = event_x (event); + last_sy = event_y (event); + + if (event_is_down (event)) { + if (reading_imcursor) { + /* The left mouse button may be used to alias keyboard + * events. Typing ctrl/button causes the last key to be + * aliased with the indicated button. Thereafter, pressing + * that mouse button during a cursor read causes the cursor + * read to terminate, returning the aliased key just as if + * the key had been typed on the keyboard. + */ + if (event_ctrl_is_down (event)) { + if (key == MS_LEFT) + key_left = last_key; + } else if (reading_imcursor) { + if (key == MS_LEFT) + key = key_left; + if (key) + goto readcur; + } + + } else if (display_coords && state==TRACK_CURSOR) { + /* Add an object to a cursor list. */ + mark_object (event); + } + } + break; + + case MS_MIDDLE: + /* Pan - move the object under the cursor to the center of the + * display window (or as close as possible without wraparound). + */ + if (event_is_up (event)) { + int fb_ex, fb_ey, fb_mx, fb_my, fb_xc, fb_yc, fb_nx, fb_ny; + int pw_xc, pw_yc, dx, dy, n_x, n_y; + int newzoom, close=1; + + /* Pressing the middle button without moving the mouse causes + * the zoom factor to be advanced. In other words, placing + * the mouse on a feature and pressing the "zoom/pan" button + * causes that feature to be moved to the center of the + * display; pressing the button again causes the display to be + * zoomed about the centered feature. + */ + newzoom = zoom; + n_x = event_x(event); + n_y = event_y(event); + + if (abs(n_x-last_bx) <= close && abs(n_y-last_by) <= close) { + if (++zoom_index >= nzooms) + zoom_index = 0; + newzoom = zooms[zoom_index]; + } + + last_sx = last_bx = n_x; + last_sy = last_by = n_y; + + pw_xc = pw_rect.r_width / 2; /* window center in pw */ + pw_yc = pw_rect.r_height / 2; + fb_mx = pw_rect.r_left + n_x; /* final mouse position */ + fb_my = pw_rect.r_top + n_y; + fb_xc = pw_rect.r_left + pw_xc; /* window center in fb */ + fb_yc = pw_rect.r_top + pw_yc; + fb_nx = fb_ex = fb_mx; /* next center */ + fb_ny = fb_ey = fb_my; + + dx = n_x - pw_xc; /* step size */ + dy = n_y - pw_yc; + + /* Pan a long ways in the indicated direction, normally to the + * edge of the image. + */ + if (event_shift_is_down (event)) { + fb_ex = fb_nx = fb_mx = + max(pw_xc, min(fb_rect.r_width - pw_xc, fb_xc + dx*5)); + fb_ey = fb_ny = fb_my = + max(pw_xc, min(fb_rect.r_height - pw_yc, fb_yc + dy*5)); + if (!event_ctrl_is_down (event)) + dx = dy = 0; + } + + /* Smooth pan to ex,ey. May be combined with shift-pan. */ + if (event_ctrl_is_down (event)) { + dx = dx ? dx / abs(dx) : 0; + dy = dy ? dy / abs(dy) : 0; + + /* Increase step size if window is large. */ + if (pw_rect.r_width * pw_rect.r_height > 200000) { + dx *= 2; + dy *= 2; + } + + fb_nx = max(0, min(fb_rect.r_width, fb_xc + dx)); + fb_ny = max(0, min(fb_rect.r_height, fb_yc + dy)); + } + + /* Go to x,y starting at nx,ny stepping dx,dy per frame. */ + if (fb_nx != fb_xc || fb_ny != fb_yc || zoom != newzoom) + start_pan (fb_mx,fb_my, fb_nx,fb_ny, fb_ex,fb_ey, dx,dy, + newzoom); + } + break; + + case INTERRUPT: + /* Abort any lengthy operation currently in progress. */ + if (reading_imcursor) + goto readcur; + else + stop_pan(); + break; + + case NEXT_SCREEN: + /* Display the next screen in numerical sequence. */ + set_frame (0); + if (display_coords && state == TRACK_CURSOR) + update_coords (event); + break; + + case PREV_SCREEN: + /* Display the previous screen in numerical sequence. */ + set_frame (-1); + if (display_coords && state == TRACK_CURSOR) + update_coords (event); + break; + + case CYCLE_BLINK: + /* Display the next screen from the blink frames list. + * The frames in the blink frame list do not have to exist; + * if not, then advance through the list until either a valid + * frame is found, or the list has been traversed once. + */ + if (n_blink_frames > 0 && window_open) { + int frame, n; + for (n=n_blink_frames; --n >= 0; ) { + if (++blink_frame >= n_blink_frames) + blink_frame = 0; + frame = blink_frames[blink_frame]; + if (frame >= 1 && frame <= fb_nframes) { + set_frame (frame); + if (display_coords && state == TRACK_CURSOR) + update_coords (NULL); + break; + } + } + } + break; + + default: + /* Terminate a cursor read, returning the encoded cursor value + * sequence to client program on the output datastream. + */ + if (event_is_down(event) && + (event_is_ascii(event) || event_is_key_right(event))) { +readcur: + last_sx = event_x (event); + last_sy = event_y (event); + + /* Terminate cursor read? */ + if (reading_imcursor) { + register struct ctran *ct; + int wcs = imcursor_wcs; + int sx, sy; + float wx, wy; + + /* Map keypad function keys to digits. */ + if (event_is_key_right(event)) { + switch (key = event_id(event) - KEY_RIGHT(1) + 1) { + case 7: case 8: case 9: + break; + case 10: case 11: case 12: + key -= 6; + break; + case 13: case 14: case 15: + key -= 12; + break; + default: + return (value); + } + key += '0'; + } + + last_x = event_x (event); + last_y = event_y (event); + last_key = key; + + wx = sx = last_x + pw_rect.r_left; + wy = sy = last_y + pw_rect.r_top; + + if (wcs) { + ct = wcs_update (df_p); + if (ct->valid) { + if (abs(ct->a) > .001) + wx = sx * ct->a + ct->tx; + if (abs(ct->d) > .001) + wy = sy * ct->d + ct->ty; + } + } + + /* Map ctrl/d and ctrl/z into EOF. */ + if (key == '\004' || key == '\032') + key = EOF; + else if (marktype) { + /* Mark the cursor position? */ + edit_framebuffer (df_p, sx/zoom - 8, sy/zoom - 8, + marker[marktype], + PIX_NOT(PIX_SRC) & PIX_DST); + } + + /* Return the cursor value on the output datastream encoded + * in a fixed size ascii buffer. + */ + gio_retcursorval (wx, wy, display_frame*100+wcs, key, ""); + + /* Terminate the cursor read. */ + gio_restorecursor(); + } + } + } + + return (value); +} + + +static int p_dx, p_dy; +static int p_sx, p_sy; +static int p_left, p_top; +static int p_svdc; + +/* START_PAN -- Pan the image smoothly to the indicated position. This can + * take a while, so we want to do it on a timer and provide for interrupt. + * A new pan can be started to change the destination while an old pan is + * still in progress. + */ +static +start_pan (fb_mx,fb_my, fb_nx,fb_ny, fb_ex,fb_ey, dx,dy, newzoom) +int fb_mx, fb_my; /* mouse position in frame buffer */ +int fb_nx, fb_ny; /* center of window at next display */ +int fb_ex, fb_ey; /* center of window at final display */ +int dx, dy; /* step size for pan */ +register int newzoom; /* new zoom factor */ +{ + register int w, h; + int n_left, n_top; + int n_sx, n_sy, e_sx, e_sy; + + if (!panning) { + p_svdc = display_coords; + display_coords = 0; + panning++; + } + + p_cursor_setback = 9; + gio_setcursor (CURSOR_OFF, 0); + + Bpw_get_region_rect (gio_pw, &pw_rect); + w = pw_rect.r_width; + h = pw_rect.r_height; + + /* Scale zoomed frame buffer units to new zoom factor. + */ + p_sx = fb_mx * newzoom / zoom; + p_sy = fb_my * newzoom / zoom; + n_sx = fb_nx * newzoom / zoom; + n_sy = fb_ny * newzoom / zoom; + e_sx = fb_ex * newzoom / zoom; + e_sy = fb_ey * newzoom / zoom; + p_dx = dx * newzoom; + p_dy = dy * newzoom; + + /* The following are the final left,top values. */ + p_left = max(0, min(Fb_width*newzoom - w, + (e_sx - w/2) / newzoom * newzoom)); + p_top = max(0, min(Fb_height*newzoom - h, + (e_sy - h/2) / newzoom * newzoom)); + + /* The following are the left,top values for the next display. */ + n_left = max(0, min(Fb_width*newzoom - w, + (n_sx - w/2) / newzoom * newzoom)); + n_top = max(0, min(Fb_height*newzoom - h, + (n_sy - h/2) / newzoom * newzoom)); + + /* Set the new zoom factor for the display. */ + set_zoom (df_p, n_left, n_top, newzoom); + + notify_post_event (ev_panner, NULL, NOTIFY_SAFE); +} + + +/* STOP_PAN -- Called to abort a pan. */ +static +stop_pan() +{ + p_dx = p_dy = 0; +} + + +/* PANNER -- Called on a fast timer to do the panning. */ +static Notify_value +ev_panner() +{ + register int left, top; + + /* No clipping is done, so the imtool window must be exposed. */ + window_set (gio_frame, WIN_SHOW, TRUE, 0); + + /* repaint (P_IMAGE|P_DONTCLIP); */ + repaint (P_IMAGE); + + if (p_dx < 0 && pw_rect.r_left <= p_left || + p_dx > 0 && pw_rect.r_left >= p_left) + p_dx = 0; + else if (p_dx) { + left = pw_rect.r_left + p_dx; + if (p_dx < 0) + left = max (p_left, left); + else + left = min (p_left, left); + df_p->fb_xoff = pw_rect.r_left = left; + } + + if (p_dy < 0 && pw_rect.r_top <= p_top || + p_dy > 0 && pw_rect.r_top >= p_top) + p_dy = 0; + else if (p_dy) { + top = pw_rect.r_top + p_dy; + if (p_dy < 0) + top = max (p_top, top); + else + top = min (p_top, top); + df_p->fb_yoff = pw_rect.r_top = top; + } + + if (p_dx == 0 && p_dy == 0) { + if (panning) { + panning = 0; + display_coords = p_svdc; + if (p_cursor_setback > 0) { + int sx = p_sx - pw_rect.r_left; + int sy = p_sy - pw_rect.r_top; + if (sx >= 0 && sx < pw_rect.r_width && + sy >= 0 && sy < pw_rect.r_height) + gio_setcursorpos (sx, sy); + gio_setcursor (CURSOR_ON, 0); + gio_events(); + } + repaint (P_GRAPHICS|P_COLORBAR); + } + } else { + /* Allow the window to process any pending events. */ + gio_events(); + + /* Post another call to the panner. */ + notify_post_event (ev_panner, NULL, NOTIFY_SAFE); + } + + return (NOTIFY_DONE); +} + + +/* EDIT_FRAMEBUFFER -- Edit a frame buffer by operating upon it with the + * given pixrect and rasterop at the given location, clipping as necessary + * at the boundaries of the frame. Update the display window as well, if + * the frame being edited is the display frame. + */ +static +edit_framebuffer (fb, x, y, pr, rop) +struct framebuf *fb; /* frame to be edited */ +int x, y; /* left,top coords of rect to be edited */ +struct pixrect *pr; /* pixrect to be used */ +int rop; /* rasterop defining operation */ +{ + int width = pr->pr_width, height = pr->pr_height; + int s_left = 0, s_top = 0; + int d_left = x, d_top = y; + + /* Clip to the frame boundary. */ + while (d_left < 0) { + s_left++; + width--; + d_left++; + } + + while (d_left + width-1 > Fb_width) + width--; + + while (d_top < 0) { + s_top++; + height--; + d_top++; + } + + while (d_top + height-1 > Fb_height) + height--; + + /* All done if there is nothing left after clipping. */ + if (width*height <= 0) + return; + + /* Edit the frame buffer (clobbers the display pixels). */ + pr_rop (fb->fb_pr, d_left, d_top, width, height, + PIX_NOT(PIX_SRC) & PIX_DST, pr, s_left, s_top); + + /* Refresh the display, if the current display frame is the + * same as the reference frame. + */ + if (fb == df_p) { + BRect fb_r, pw_r; + + fb_r.r_left = d_left * zoom; + fb_r.r_top = d_top * zoom; + fb_r.r_width = width * zoom; + fb_r.r_height = height * zoom; + + Bpw_get_region_rect (gio_pw, &pw_rect); + Bpw_lock (gio_pw, &pw_rect); + + pw_rect.r_left = df_p->fb_xoff; + pw_rect.r_top = df_p->fb_yoff; + + if (maprect (&fb_rect, &fb_r, &pw_rect, &pw_r)) + if (maprect (&pw_rect, &pw_r, &fb_rect, &fb_r)) { + ds_write (gio_pw, + pw_r.r_left, pw_r.r_top, + pw_r.r_width, pw_r.r_height, + PIX_SRC | PIX_COLOR(NGREY-1), + df_p->fb_pr, fb_r.r_left, fb_r.r_top); + + if (pw_r.r_top + pw_r.r_height >= pw_rect.r_height + - cb_height) + put_colorbar(); + } + + Bpw_unlock (gio_pw); + } +} + + +/* GIO_EVENTS -- Have the image window process any queued input events. + */ +static +gio_events() +{ + Event event; + int fd, flags; + + /* Allow the window to process any pending events. */ + fd = (int) window_get (gio_canvas, WIN_FD); + flags = fcntl (fd, F_GETFL, 0); + fcntl (fd, F_SETFL, O_NDELAY); + while (window_read_event (gio_canvas, &event) != -1) + ev_gioinput (gio_canvas, + canvas_event(gio_canvas, &event), NULL, PANNER_EVENT); + fcntl (fd, F_SETFL, flags); +} + + +/* ICLEAR_PROC -- Clear the main (image) window. + */ +static +iclear_proc() +{ + erase (df_p); +} + + +/* GCLEAR_PROC -- Clear the graphics overlay. + */ +static +gclear_proc() +{ + df_p->fb_objno = 1; + repaint (P_IMAGE|P_COLORBAR); +} + + +/* SETFRAME_PROC -- Select the next frame for viewing. + */ +static +setframe_proc() +{ + set_frame (0); +} + + +/* SET_FRAME -- Set the display frame. Call with frameno=0 to advance to + * the next frame, -N will yield the previous frame in sequence, and + * anything else is actual frame number. + */ +static +set_frame (frameno) +int frameno; +{ + if (frameno < 0) { + frameno = display_frame - 1; + if (frameno < 1) + frameno = fb_nframes; + } else if (frameno == 0) { + frameno = display_frame + 1; + if (frameno > fb_nframes) + frameno = 1; + } else { + if (frameno < 1) + frameno = 1; + else if (frameno > fb_nframes) + frameno = fb_nframes; + } + + display_frame = frameno; + df_p = frames + (frameno - 1); + set_zoom (df_p, df_p->fb_xoff, df_p->fb_yoff, df_p->fb_xzoom); + + set_colortable(); + set_transfer_function (gio_pw, df_p->fb_center, df_p->fb_slope); + window_set (gio_frame, FRAME_LABEL, framelabel(), 0); + panel_set_value (pan_set_maptype, df_p->fb_maptype); + + repaint (P_IMAGE|P_COLORBAR|P_GRAPHICS); +} + + +/* SET_ZOOM -- Change the zoom factor for the referenced frame to the given + * value. If the referenced frame is the display frame, update the global + * display zoom factors as well. + */ +static +set_zoom (fr, left, top, newzoom) +register struct framebuf *fr; /* frame to be zoomed */ +int left, top; /* new left and top for frame */ +int newzoom; /* new zoom factor */ +{ + register struct ctran *ct; + int fb_zoom, i; + + /* Verify valid zoom factor. */ + newzoom = max(zooms[0], min(zooms[nzooms-1], newzoom)); + for (i=0; i < nzooms; i++) + if (zooms[i] == newzoom) { + zoom_index = i; + break; + } + + /* Set the new frame buffer zoom factor. */ + if ((fb_zoom = fr->fb_xzoom) != newzoom) { + ct = &fr->fb_ctran; + ct->a = ct->a * fb_zoom / newzoom; + ct->d = ct->d * fb_zoom / newzoom; + + /* For Apply a 0.5 pixel correction when zooming, to make the + * center of the pixel have integral coordinates (coord X,Y where + * X and Y are integral will always be the center of a pixel). + * This should be turned off for zoom=1, since there is no + * subpixel resolution, or if the image has already been zoomed + * at the host level. + */ + if (abs(ct->a * newzoom) < 1.01) { + if (fb_zoom == 1) + ct->tx += (ct->a > 0) ? -0.5 : 0.5; + else if (newzoom == 1) + ct->tx += (ct->a > 0) ? 0.5 : -0.5; + } + if (abs(ct->d * newzoom) < 1.01) { + if (fb_zoom == 1) + ct->ty += (ct->d > 0) ? -0.5 : 0.5; + else if (newzoom == 1) + ct->ty += (ct->d > 0) ? 0.5 : -0.5; + } + + fr->fb_xzoom = fr->fb_yzoom = newzoom; + } + + /* Offsets must be aligned to an unzoomed frame buffer pixel + * boundary since this constraint is applied in ds_write. + */ + fr->fb_xoff = max(0, min(Fb_width*newzoom - pw_rect.r_width, + left / newzoom * newzoom)); + fr->fb_yoff = max(0, min(Fb_height*newzoom - pw_rect.r_height, + top / newzoom * newzoom)); + + /* If the referenced frame is the display frame, make the new zoom + * factor global. + */ + if (fr == df_p) { + fb_width = Fb_width * newzoom; + fb_height = Fb_height * newzoom; + + fb_rect.r_top = 0; + fb_rect.r_left = 0; + fb_rect.r_width = fb_width; + fb_rect.r_height = fb_height; + + pw_rect.r_left = df_p->fb_xoff; + pw_rect.r_top = df_p->fb_yoff; + + zoom = newzoom; + } +} + + +/* ERASE -- Clear a frame. + */ +static +erase (fr) +struct framebuf *fr; +{ + register int *op, v, n; + unsigned char *cp; + int val; + + for (val=0, n=sizeof(int), cp = (unsigned char *)&val; --n >= 0; ) + *cp++ = background; + + if (val) { + op = (int *) mpr_d(fr->fb_pr)->md_image; + n = Fb_width * Fb_height / sizeof(int); + for (v=val; --n >= 0; ) + *op++ = v; + } else + bzero ((char *)mpr_d(fr->fb_pr)->md_image, Fb_width * Fb_height); + + if (fr == df_p) + repaint (P_IMAGE|P_COLORBAR); +} + + +/* REPAINT -- Repaint the display window. + */ +static +repaint (what) +int what; +{ + if (what & P_IMAGE) { + BRect fb_r, pw_r; + int rop; + + pw_r = pw_rect; + pw_r.r_left = pw_r.r_top = 0; + if (what & P_COLORBAR) + pw_r.r_height -= cb_height; + + rop = PIX_SRC | PIX_COLOR(NGREY-1); + if (what & P_DONTCLIP) + rop |= PIX_DONTCLIP; + + if (maprect (&pw_rect, &pw_r, &fb_rect, &fb_r)) + if (maprect (&fb_rect, &fb_r, &pw_rect, &pw_r)) + ds_write (gio_pw, + pw_r.r_left, pw_r.r_top, pw_r.r_width, pw_r.r_height, + rop, df_p->fb_pr, fb_r.r_left, fb_r.r_top); + + if (display_coords && state == TRACK_CURSOR) { + set_wcsboxpos(); + pw_text (gio_pw, wc_xoff, wc_yoff + wc_font->pf_defaultsize.y, + PIX_NOT(PIX_SRC), wc_font, wc_text); + } + } + + if (what & P_COLORBAR) + put_colorbar(); + + if ((what & P_GRAPHICS) && df_p->fb_objno > 1) { + char fname[SZ_FNAME]; + + wcs_update (df_p); + sprintf (fname, o_fname, df_p->fb_frameno, df_p->fb_imageno); + strcpy (fname, getfname(fname, 0)); + remark_objects (fname); + } +} + + +/* REFRESH_DISPLAY -- Called by the windowing system when the display needs + * to be refreshed from the frame buffer. + */ +static +refresh_display (canvas, pw, rl) +Canvas canvas; +Pixwin *pw; +Rectlist *rl; +{ + register struct rectnode *rn; + BRect fb_r, pw_r; + Rect rect, r; + + /* See if any damage has occurred and fix it. */ + rl_rectoffset (rl, &rl->rl_bound, &rect); + pw_lock (pw, &rect); + + /* Now fix all the damage. Regions of the display window which are + * not mapped onto the frame buffer are not fixed up at present. + * Scale changes (zoom/dezoom) are not currently immplemented. + */ + for (rn = rl->rl_head; rn; rn = rn->rn_next) { + rl_rectoffset (rl, &rn->rn_rect, &r); + pw_r.r_left = r.r_left; + pw_r.r_top = r.r_top; + pw_r.r_width = r.r_width; + pw_r.r_height = r.r_height; + + if (maprect (&pw_rect, &pw_r, &fb_rect, &fb_r)) + if (maprect (&fb_rect, &fb_r, &pw_rect, &pw_r)) + ds_write (pw, + pw_r.r_left, pw_r.r_top, pw_r.r_width, pw_r.r_height, + PIX_SRC | PIX_COLOR(NGREY-1), + df_p->fb_pr, fb_r.r_left, fb_r.r_top); + } + + put_colorbar(); + pw_unlock (pw); +} + + +/* DS_WRITE -- Write to the display. This is analogous to pw_write, except + * that pixel replication or subsampling is performed as indicated by the + * zoom factors for the current display frame. At present, the zoom factor + * may not be specified independently for x and y. + */ +static +ds_write (pw, left, top, width, height, rop, fb_pr, fb_left, fb_top) +Pixwin *pw; +int left, top; +int width, height; +int rop; +Pixrect *fb_pr; +int fb_left, fb_top; /* zoomed frame buffer coords */ +{ + register unsigned char pix, *ip, *op; + register int n, p; + unsigned char *otop, *fb, *lp; + int pr_left, pr_top, i, j; + Pixrect *mpr_line, *pr; + struct rect pw_r; + + if (width <= 0 || height <= 0) + return; + + /* If no zoom, just copy the frame buffer rect to the screen. */ + if (zoom <= 1) { + pw_write (pw, left,top, width,height, rop, fb_pr, fb_left,fb_top); + return; + } + + /* Zoom - magnify the image by pixel replication. (This assumes an + * 8 bit frame buffer and screen pixrect). + */ + mpr_line = mem_create (width, 1, pw->pw_pixrect->pr_depth); + fb = (unsigned char *)mpr_d(df_p->fb_pr)->md_image; + lp = (unsigned char *)mpr_d(mpr_line)->md_image; + otop = lp + width; + + /* Lock the frame buffer to avoid scribbling on other windows + * during write to raw screen.. + */ + pw_get_region_rect (pw, &pw_r); + pw_lock (pw, &pw_r); + + pr = pw->pw_pixrect; + pr_left = left + (int)window_get(gio_frame, WIN_X) + TOOL_BORDERWIDTH; + pr_top = top + (int)window_get(gio_frame, WIN_Y) + + HEIGHTADJUST - TOOL_BORDERWIDTH; + + for (j=0, i=(fb_top/zoom); j < height; j += zoom) { + ip = fb + (i++ * Fb_width) + (fb_left/zoom); + op = lp; + + /* Replicate a block of pixels. */ + switch (zoom) { + case 2: + for (n = (width/2); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; + } + break; + case 3: + for (n = (width/3); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; *op++ = pix; + } + break; + case 4: + for (n = (width/4); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + } + break; + case 5: + for (n = (width/5); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + } + break; + case 6: + for (n = (width/6); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; *op++ = pix; + } + break; + case 7: + for (n = (width/7); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + } + break; + case 8: + for (n = (width/8); --n >= 0; ) { + pix = *ip++; + *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + *op++ = pix; *op++ = pix; + } + break; + default: + for (n = (width/zoom); --n >= 0; ) { + pix = *ip++; + for (p=zoom; --p >= 0; ) + *op++ = pix; + } + break; + } + + /* Fill the last partial pixel. */ + pix = *ip++; + while (op < otop) + *op++ = pix; + + pr_replrop (pr, pr_left,pr_top+j, + width, min (height-j, zoom), rop, mpr_line, 0,0); + } + + pw_unlock (pw); + pr_close (mpr_line); +} + + +/* PUT_COLORBAR -- Refresh the colorbar on the screen. + */ +static +put_colorbar() +{ + if (cb_height) + pw_write (gio_pw, + 0, pw_rect.r_height - cb_height, + min (pw_rect.r_width, Fb_width), cb_height, + PIX_SRC, cb_pr, 0, 0); +} + + +/* TOGGLE_DISPLAYCOORDS -- Enable/disable continuous display of the cursor + * coordinates. + */ +static +toggle_displaycoords (event) +Event *event; +{ + BRect fb_r, pw_r; + + if (display_coords) { + /* Enable mouse moved input events. */ + window_set (gio_canvas, WIN_IGNORE_PICK_EVENTS, LOC_MOVE, 0, + 0); + display_coords = 0; + + /* Refresh the region of the screen used to output coordinates + * from the frame buffer, erasing the coordinate output box. + */ + pw_r.r_left = wc_xoff; + pw_r.r_top = wc_yoff; + pw_r.r_width = wc_width; + pw_r.r_height = wc_height; + + if (maprect (&pw_rect, &pw_r, &fb_rect, &fb_r)) + ds_write (gio_pw, + wc_xoff, wc_yoff, wc_width, wc_height, + PIX_SRC | PIX_COLOR(NGREY-1), + df_p->fb_pr, fb_r.r_left, fb_r.r_top); + + } else { + /* Disable mouse moved input events. */ + window_set (gio_canvas, WIN_CONSUME_PICK_EVENTS, LOC_MOVE, 0, + 0); + display_coords = 1; + update_coords (event); + } +} + + +/* UPDATE_COORDS -- Compute and output the world coordinates of the given + * event, using the WCS specified for the current display window. If called + * with event=NULL the most recent locator position is used. + */ +static +update_coords (event) +Event *event; +{ + register struct ctran *ct; + static struct timeval o_tv; + unsigned char *fb, *ip; + struct timeval n_tv; + int sx, sy, sz, fb_x, fb_y, delta_msec; + char buf[1024], ch; + float wx, wy, wz; + + /* Get frame buffer x,y; ignore events that occur faster than we + * can update the coordinate readout. + */ + if (event) { + /* Ignore event if it comes too soon. */ + n_tv = event_time(event); + if (o_tv.tv_sec) { + delta_msec = ((n_tv.tv_sec - o_tv.tv_sec) * 1000 + + (n_tv.tv_usec - o_tv.tv_usec) / 1000); + if (delta_msec < 50) + return; + } + + /* Get the screen (window relative) coordinates of the event. */ + sx = event_x(event) + pw_rect.r_left; + sy = event_y(event) + pw_rect.r_top; + + } else { + sx = last_sx + pw_rect.r_left; + sy = last_sy + pw_rect.r_top; + } + + /* Get frame buffer pixel value. */ + fb = (unsigned char *) mpr_d (df_p->fb_pr)->md_image; + fb_x = max(0, min(Fb_width, sx/zoom)); + fb_y = max(0, min(Fb_height, sy/zoom)); + sz = fb[fb_y*Fb_width+fb_x]; + if (sz < CMS_DATASTART || sz > CMS_DATAEND) + sz = 0; + + /* Compute the world coordinates of the event. */ + ct = wcs_update (df_p); + + if (ct->valid) { + wx = ct->a * sx + ct->c * sy + ct->tx; + wy = ct->b * sx + ct->d * sy + ct->ty; + + if (sz == 0) + wz = 0.0; + else { + switch (ct->zt) { + case W_LINEAR: + wz = ((sz - CMS_DATASTART) * (ct->z2 - ct->z1) / + (CMS_DATARANGE-1)) + ct->z1; + break; + default: + wz = sz; + break; + } + } + + } else { + wx = sx; + wy = sy; + wz = sz; + } + + /* Get the font to be used. */ + if (wc_font == NULL) { + static char fontname[] = TEXT_FONT; + if ((wc_font = pf_open (fontname)) == NULL) + fprintf (stderr, "cannot open %s\n", fontname); + wc_xoff = wc_yoff = 0; + } + + ch = ' '; + if (sz && ct->valid) { + if (ct->z1 < ct->z2) { + if (wz < (ct->z1 + 0.01)) + ch = '-'; + else if (wz > (ct->z2 - 0.01)) + ch = '+'; + } else if (ct->z1 > ct->z2) { + if (wz < (ct->z2 + 0.01)) + ch = '-'; + else if (wz > (ct->z1 - 0.01)) + ch = '+'; + } + } + + set_wcsboxpos(); + sprintf (buf, ct->format, wx, wy, wz, ch); + strncpy (wc_text, buf, SZ_WCTEXT); + pw_text (gio_pw, wc_xoff, wc_yoff + wc_font->pf_defaultsize.y, + PIX_NOT(PIX_SRC), wc_font, wc_text); + + if (event) + o_tv = n_tv; +} + + +/* MARK_OBJECT -- Called when the user has clicked on the position of an + * object to be marked and/or added to the output coordinate list. + */ +static +mark_object (event) +Event *event; +{ + register struct ctran *ct; + char tx_buf[SZ_FNAME]; + char fname[SZ_FNAME]; + int sx, sy, newset; + float wx, wy; + FILE *fp; + + ct = wcs_update (df_p); + + /* Get name of coordinate output file for the current frame. */ + sprintf (tx_buf, o_fname, df_p->fb_frameno, df_p->fb_imageno); + strcpy (fname, getfname(tx_buf, 0)); + + /* Append to the existing coordinate list, if any. If appending + * to an existing coordinate list, the existing list is displayed + * and the objno counter is left set to the next object to be added. + */ + if (newset = (df_p->fb_objno <= 1)) + remark_objects (fname); + if ((fp = fopen (fname, "a")) == NULL) { + fprintf (stderr, "cannot open %s for appending\n", fname); + return; + } + + /* Timestamp the first entry in the output file. */ + if (newset) + timestamp (fp); + + /* Get the screen (window relative) coordinates of the event. */ + sx = event_x(event) + pw_rect.r_left; + sy = event_y(event) + pw_rect.r_top; + + /* Compute the world coordinates of the event. */ + if (ct->valid) { + wx = ct->a * sx + ct->c * sy + ct->tx; + wy = ct->b * sx + ct->d * sy + ct->ty; + } else { + wx = sx; + wy = sy; + } + + /* Mark the object position on the screen. */ + sprintf (tx_buf, "%d", df_p->fb_objno++); + draw_text (sx - pw_rect.r_left, sy - pw_rect.r_top, tx_buf); + + fprintf (fp, "%g %g\n", wx, wy); + fclose (fp); +} + + +/* REMARK_OBJECTS -- Read a object list file and mark the numbered objects + * therein. + */ +static +remark_objects (fname) +char *fname; +{ + register struct ctran *ct; + register char *ip; + char lbuf[SZ_LINE], tx_buf[SZ_FNAME]; + int sx, sy, objno=1; + float wx, wy; + char *fgets(); + FILE *fp; + + gclear_proc(); + window_set (gio_frame, FRAME_LABEL, framelabel(), 0); + if ((fp = fopen (fname, "r")) == NULL) + return; + + while (fgets (lbuf, SZ_LINE, fp) != NULL) { + /* Skip comment lines and blank lines. */ + for (ip=lbuf; *ip == ' ' || *ip == '\t'; ip++) + ; + if (*ip == '\n' || *ip == '#') + continue; + if (!isdigit (*ip) && *ip != '-') + continue; + if (sscanf (ip, "%f%f", &wx, &wy) < 2) + continue; + + sx = wx; + sy = wy; + + /* Compute the world coordinates of the event if we have a valid + * WCS transform (rotations not permitted)/ + */ + ct = wcs_update (df_p); + if (ct->valid) { + if (abs(ct->a) > .001) + sx = (wx - ct->tx) / ct->a; + if (abs(ct->d) > .001) + sy = (wy - ct->ty) / ct->d; + } + + /* Mark the object position on the screen. */ + sprintf (tx_buf, "%d", objno++); + draw_text (sx - pw_rect.r_left, sy - pw_rect.r_top, tx_buf); + } + + fclose (fp); + + /* If we are updating an existing coordinate list from a newly + * displayed frame, timestamp the new section of the list. + */ + if (df_p->fb_objno <= 1) + if ((fp = fopen (fname, "a")) != NULL) { + timestamp (fp); + fclose (fp); + } + + df_p->fb_objno = objno; +} + + +/* TIMESTAMP -- Timestamp the output stream. + */ +static +timestamp (fp) +FILE *fp; +{ + register char *op; + char obuf[SZ_LINE]; + long clock; + + clock = time(0); + fprintf (fp, "# %s", asctime(localtime(&clock))); + + sprintf (obuf, "# %s", df_p->fb_label); + for (op=obuf; *op && *op != '\n'; op++) + ; + *op++ = '\n'; + *op = '\0'; + fputs (obuf, fp); +} + + +/* DRAW_TEXT -- Draw some text on the frame at the indicated position. + */ +static +draw_text (x, y, text) +int x, y; /* position where text is to be drawn */ +char *text; /* the text */ +{ + static struct pixfont *font = NULL; + + /* Get the screen font to be used. */ + if (font == NULL) { + static char fontname[] = MARK_FONT; + if ((font = pf_open (fontname)) == NULL) + fprintf (stderr, "cannot open %s\n", fontname); + } + + /* Draw the text. */ + if (o_revtext) + pw_text (gio_pw, x, y, PIX_NOT(PIX_SRC) & PIX_DST, font, text); + else + pw_text (gio_pw, x, y, PIX_SRC | PIX_DST, font, text); +} + + +/* WCS_UPDATE -- Load the screen WCS, if not yet validated, from the user + * wcs file, if any. + * + * File format (two lines): + * + * image title (imtool header label string)\n + * a b c d tx ty z1 z2 zt + * + * NOTE: the WCS text is now passed in via the data stream as a write to the + * subunit WCS and left in the buffer "wcsbuf", rather than being passed via + * a text file. + */ +static struct ctran * +wcs_update (fr) +struct framebuf *fr; +{ + register struct ctran *ct = &fr->fb_ctran; + char buf[1024], *format; + + /* Get the new WCS. */ + if (!ct->valid) { + fr->fb_label[0] = '\0'; + ct->zt = W_UNITARY; + + /* Attempt to read the WCS file and set up a unitary transformation + * if the file cannot be read. + */ + if (sscanf (wcsbuf[fr->fb_frameno-1], "%[^\n]\n%f%f%f%f%f%f%f%f%d", + buf, &ct->a, &ct->b, &ct->c, &ct->d, &ct->tx, &ct->ty, + &ct->z1, &ct->z2, &ct->zt) < 7) { + + if (wcsbuf[fr->fb_frameno-1][0]) + fprintf (stderr, "imtool: error reading WCS file\n"); + + strncpy (ct->imtitle, "[NO WCS]\n", SZ_IMTITLE); + ct->a = ct->d = 1; + ct->b = ct->c = 0; + ct->tx = ct->ty = 0; + ct->zt = W_UNITARY; + + } else + strncpy (ct->imtitle, buf, SZ_IMTITLE); + + /* Correct for the current zoom factor, if any. */ + if (fr->fb_xzoom > 1) { + if (abs(ct->a) < 1.01) + ct->tx += (ct->a > 0) ? -0.5 : 0.5; + if (abs(ct->d) < 1.01) + ct->ty += (ct->d > 0) ? -0.5 : 0.5; + ct->a = ct->a / fr->fb_xzoom; + ct->d = ct->d / fr->fb_xzoom; + } + + window_set (gio_frame, FRAME_LABEL, framelabel(), 0); + ct->valid++; + } + + /* Determine best format for wcs output. */ + if (ct->valid && ct->zt == W_LINEAR) { + float z1, z2, zrange; + z1 = ct->z1; + z2 = ct->z2; + zrange = (z1 > z2) ? z1 - z2 : z2 - z1; + if (zrange < 100.0 && (abs(z1) + abs(z2)) / 2.0 < 200.0) + format = " %7.2f %7.2f %7.3f%c"; + else if (zrange > 99999.0 || (abs(z1) + abs(z2)) / 2.0 > 99999.0) + format = " %7.2f %7.2f %7.3g%c"; + else + format = W_DEFFORMAT; + } else + format = " %7.2f %7.2f %7.0f%c"; + + strcpy (ct->format, format); + return (ct); +} + + +/* SET_WCSBOXPOS -- Set the position of the WCS output box. + */ +static +set_wcsboxpos() +{ + /* Compute offset to coordinate output box. */ + if ((wc_xoff + wc_yoff) == 0) { + wc_width = wc_font->pf_defaultsize.x * 25; + wc_height = wc_font->pf_defaultsize.y + 5; + wc_xoff = max (0, min (Fb_width, pw_rect.r_width) - wc_width + - TOOL_BORDERWIDTH); + wc_yoff = max (0, pw_rect.r_height - cb_height - wc_height + - TOOL_BORDERWIDTH); + } +} + + +/* FRAMELABEL -- Return a pointer to the frame label string for the current + * frame. + */ +static char * +framelabel() +{ + char fname[SZ_FNAME]; + char label[SZ_LABEL*2]; + + sprintf (fname, o_fname, df_p->fb_frameno, df_p->fb_imageno); + sprintf (label, "[%d] %s: %s", df_p->fb_frameno, fname, + df_p->fb_ctran.imtitle); + strncpy (df_p->fb_label, label, SZ_LABEL); + + return (df_p->fb_label); +} + + +/* GETFNAME -- Construct the pathname of a user datafile. One optional + * integer argument is permitted. + */ +static char * +getfname (rootname, arg) +char *rootname; /* root filename (printf style format) */ +int arg; +{ + static char pathname[SZ_FNAME]; + char fmt[SZ_LINE], *udir; + + /* Were we passed an absolute pathname as input? */ + if (*rootname == '/') { + strcpy (pathname, rootname); + return (pathname); + } + + if ((udir = getenv ("WCSDIR")) == NULL) + if ((udir = getenv ("wcsdir")) == NULL) + if ((udir = getenv ("HOME")) == NULL) + udir = "/tmp"; + + sprintf (fmt, "%s/%s", udir, rootname); + sprintf (pathname, fmt, arg); + + return (pathname); +} + + +/* GIO_SETCURSOR -- Set graphics frame cursor options. + */ +static +gio_setcursor (op1, op2) +int op1, op2; +{ + Cursor cursor; + int option[2], i; + int blink=cursor_blink, show=cursor_show; + + /* Normalize the argument list. */ + for (option[0]=op1, option[1]=op2, i=0; i < 2; i++) + switch (option[i]) { + case BLINK_OFF: + case BLINK_ON: + blink = option[i]; + break; + case CURSOR_OFF: + case CURSOR_ON: + show = option[i]; + break; + } + + /* Do we need to change anything? */ + if (blink == cursor_blink && show == cursor_show) + return; + + /* Modify the cursor attributes. */ + if (show == CURSOR_ON && reading_imcursor) + gio_readcursor (imcursor_wcs); + else { + cursor = window_get (gio_canvas, WIN_CURSOR); + cursor_set (cursor, + CURSOR_SHOW_CURSOR, FALSE, + CURSOR_SHOW_CROSSHAIRS, (show == CURSOR_ON), + CURSOR_CROSSHAIR_THICKNESS, 1, + CURSOR_CROSSHAIR_LENGTH, 20, + CURSOR_CROSSHAIR_GAP, 6, + +#ifdef sparc + /* This is a kludge to work around a bug with the + * sparcstation 1 under 4.0.3. */ + CURSOR_CROSSHAIR_OP, PIX_SRC ^ PIX_DST, +#else + CURSOR_CROSSHAIR_OP, PIX_SRC, +#endif + + CURSOR_CROSSHAIR_COLOR, CMS_CURSOR, + 0); + window_set (gio_canvas, WIN_CURSOR, cursor, 0); + } + + cursor_blink = blink; + cursor_show = show; +} + + +/* GIO_SETCURSORPOS -- Set the position of the graphics cursor within the + * graphics frame. + */ +static +gio_setcursorpos (x, y) +int x, y; /* pixwin pixel coords */ +{ + if (window_open) + window_set (gio_canvas, WIN_MOUSE_XY, last_bx=x, last_by=y, 0); +} + + +/* RESET_PROC -- Called from the setup panel to reset the state of the + * display. + */ +static +reset_proc() +{ + register struct pixrect *pr = get_screen_rect(); + register struct framebuf *fb; + register int i; + + stop_pan(); + blink = 0; + display_coords = 0; + setup_xoff = 4; + setup_yoff = 18; + wc_xoff = wc_yoff = 0; + state = TRACK_CURSOR; + + for (i=0; i < fb_nframes; i++) { + fb = &frames[i]; + fb->fb_xoff = 0; + fb->fb_yoff = 0; + fb->fb_xzoom = fb->fb_yzoom = 1; + fb->fb_center = fb_ngrey / 2.0; + fb->fb_slope = (float)white / (float)(fb_ngrey - 1); + fb->fb_maptype = MONO; + fb->fb_objno = 1; + fb->fb_imageno = 0; + fb->fb_frameno = i + 1; + } + + gio_xsize = initial_gio_xsize; + gio_ysize = initial_gio_ysize; + + gio_xsize = min (pr->pr_width - TOOL_BORDERWIDTH * 2, gio_xsize); + gio_ysize = min (pr->pr_height + - tool_headerheight ((int)window_get(gio_frame,FRAME_SHOW_LABEL)) + - TOOL_BORDERWIDTH, gio_ysize); + + window_set (gio_canvas, + WIN_WIDTH, gio_xsize, + WIN_HEIGHT, gio_ysize, + 0); + + window_fit (gio_canvas); + window_fit (gio_frame); + + set_frame (1); +} + + +/* MAPRECT -- Compute the intersection of the given subrect of the first rect + * with the second rect, in the coordinate system of the second. The rects + * are defined in screen coordinates, the subrects relative to their parent + * rects. + */ +maprect (r1, s1, r2, s2) +BRect *r1, *s1; /* source rect and subrect */ +BRect *r2, *s2; /* destination rect and subrect */ +{ + int xoff, yoff; + int x0, y0, x1, y1; + + /* Compute offset of second rect from the first. */ + xoff = r2->r_left - r1->r_left; + yoff = r2->r_top - r1->r_top; + + /* Translate the first subrect into the coordinate system of the + * second rect. + */ + x0 = s1->r_left - xoff; + y0 = s1->r_top - yoff; + x1 = x0 + s1->r_width - 1; + y1 = y0 + s1->r_height - 1; + + /* Does the new subrect totally miss the second rect? + */ + if (x1 < 0 || x0 >= r2->r_width || y1 < 0 || y0 >= r2->r_height) { + *s2 = *r2; + s2->r_width = s2->r_height = 0; + } else { + /* Clip the new subrect to the boundary of the second rect. + */ + if (x0 < 0) + x0 = 0; + else if (x0 >= r2->r_width) + x0 = r2->r_width - 1; + + if (x1 < 0) + x1 = 0; + else if (x1 >= r2->r_width) + x1 = r2->r_width - 1; + + if (y0 < 0) + y0 = 0; + else if (y0 >= r2->r_height) + y0 = r2->r_height - 1; + + if (y1 < 0) + y1 = 0; + else if (y1 >= r2->r_height) + y1 = r2->r_height - 1; + + /* Compute the new subrect. + */ + s2->r_left = x0; + s2->r_top = y0; + s2->r_width = x1 - x0 + 1; + s2->r_height = y1 - y0 + 1; + } + + return (s2->r_width > 0 && s2->r_height > 0); +} + + +/* BPW_GET_REGION_RECT -- Get pw_rect, transforming a Rect to a BRect. + */ +static +Bpw_get_region_rect (pw, br) +Pixwin *pw; +BRect *br; +{ + Rect r; + + pw_get_region_rect (pw, &r); + br->r_left = r.r_left; + br->r_top = r.r_top; + br->r_width = r.r_width; + br->r_height = r.r_height; +} + + +/* BPW_LOCK -- Lock a big pixwin. + */ +static +Bpw_lock (pw, br) +Pixwin *pw; +BRect *br; +{ + Rect r; + + r.r_left = br->r_left; + r.r_top = br->r_top; + r.r_width = br->r_width; + r.r_height = br->r_height; + + pw_lock (pw, &r); +} + + +/* BPW_UNLOCK -- Unlock a big pixwin. + */ +static +Bpw_unlock (pw) +Pixwin *pw; +{ + pw_unlock (pw); +} + + +/* IMAGECOPY_PROC -- Make a hardcopy of the image window on the laserwriter. + * We don't do this immediately, but rather after a delay of a few milliseconds + * to allow the window system to restore the imtool window lookup table after + * the mouse button is released. + */ +static +imagecopy_proc() +{ + static Notify_value ev_screendump(); + + window_set (gio_frame, WIN_SHOW, TRUE, 0); + imt_pause (100, ev_screendump); +} + + +/* EV_SCREENDUMP -- Called after the specified interval has passed to carry out + * the actual screendump operation. + */ +static Notify_value +ev_screendump() +{ + int depth = 8; + + edit_colormap(); + + if (snap_frame_too) { + screendump ( + (int) window_get (gio_canvas, WIN_FD), + win_get_pixwin (gio_canvas), + (int) window_get (gio_frame, WIN_WIDTH), + (int) window_get (gio_frame, WIN_HEIGHT), + (int) window_get (gio_frame, WIN_X), + (int) window_get (gio_frame, WIN_Y), + depth); + } else { + screendump ( + (int) window_get (gio_canvas, WIN_FD), + win_get_pixwin (gio_canvas), + (int) window_get (gio_frame, WIN_WIDTH) - TOOL_BORDERWIDTH * 2, + (int) window_get (gio_frame, WIN_HEIGHT) - + HEIGHTADJUST - cb_height, + (int) window_get (gio_frame, WIN_X) + TOOL_BORDERWIDTH, + (int) window_get (gio_frame, WIN_Y) + HEIGHTADJUST - + TOOL_BORDERWIDTH, + depth); + } + + return (NOTIFY_DONE); +} + + +/* IMT_PAUSE -- Suspend output for the indicated number of milliseconds, to + * allow other event processing to catch up. + */ +imt_pause (msec, ufcn) +int msec; +Notify_value (*ufcn)(); +{ + static struct itimerval itimer_delay; + + itimer_delay.it_interval.tv_usec = 0; + itimer_delay.it_interval.tv_sec = 0; + itimer_delay.it_value.tv_usec = (msec % 1000) * 1000; + itimer_delay.it_value.tv_sec = (msec / 1000); + + notify_set_itimer_func ((int)ufcn, ufcn, ITIMER_REAL, + &itimer_delay, NULL); +} + + +/* PRINT_USAGE -- Print instructions on how to use this window tool. + */ +static +print_usage (toolname) +char *toolname; +{ + printf ("no on-line help text yet for IMTOOL\n"); +} diff --git a/unix/sun/imtool.cross b/unix/sun/imtool.cross new file mode 100644 index 00000000..2e1b3532 --- /dev/null +++ b/unix/sun/imtool.cross @@ -0,0 +1,4 @@ +/* Format_version=1, Width=16, Height=16, Depth=1, Valid_bits_per_item=16 + */ + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0240,0x0180, + 0x0180,0x0240,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000 diff --git a/unix/sun/imtool.cursor b/unix/sun/imtool.cursor new file mode 100644 index 00000000..b1041fe9 --- /dev/null +++ b/unix/sun/imtool.cursor @@ -0,0 +1,4 @@ +/* Format_version=1, Width=16, Height=16, Depth=1, Valid_bits_per_item=16 + */ + 0x0000,0x03E0,0x0FF8,0x1C1C,0x380E,0x3006,0x6003,0x6003, + 0x6003,0x6003,0x6003,0x3006,0x380E,0x1C1C,0x0FF8,0x03E0 diff --git a/unix/sun/imtool.h b/unix/sun/imtool.h new file mode 100644 index 00000000..e0048a28 --- /dev/null +++ b/unix/sun/imtool.h @@ -0,0 +1,13 @@ +/* IMTOOL.H -- Global definitions for IMTOOL. + */ +#define CURSOR_OFF 3 /* turn cursor off entirely */ +#define CURSOR_ON 4 /* turn it back on */ + +struct fonttab { /* Imtool font descriptor. */ + short pointsize; + char ch_xsize, ch_ysize; + short win_xsize, win_ysize; + struct pixfont *pixfont; + char *path; + char *label; +}; diff --git a/unix/sun/imtool.icon b/unix/sun/imtool.icon new file mode 100644 index 00000000..5857c1d0 --- /dev/null +++ b/unix/sun/imtool.icon @@ -0,0 +1,66 @@ +/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16 + */ + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0FFF,0xFFFF,0xFFFF,0xFFF0, + 0x0AAA,0xAAAA,0xAAAA,0xAAB0, + 0x0D55,0x5555,0x5555,0x5550, + 0x0AAA,0xAAAA,0xAAAA,0xAAB0, + 0x0D55,0x5555,0x5555,0x5550, + 0x0AAA,0xAAAA,0xAAAA,0xAAB0, + 0x0D55,0xFFFF,0xFFD5,0x5550, + 0x0AAE,0x0000,0x003A,0xBEB0, + 0x0D58,0x0000,0x0015,0x6350, + 0x0AB0,0x0000,0x000A,0xC1B0, + 0x0D50,0x0000,0x000D,0x4150, + 0x0AA7,0xE7C1,0x07E6,0xC1B0, + 0x0D61,0x8663,0x8605,0x6350, + 0x0AA1,0x8663,0x8606,0xBEB0, + 0x0D61,0x8666,0xC605,0x5550, + 0x0AA1,0x87C6,0xC7C6,0xAAB0, + 0x0D61,0x86CC,0x6605,0x5550, + 0x0AA1,0x866F,0xE606,0xBEB0, + 0x0D61,0x866C,0x6605,0x6350, + 0x0AA7,0xE66C,0x6606,0xC1B0, + 0x0D60,0x0000,0x0005,0x4150, + 0x0AA0,0x0000,0x0006,0xC1B0, + 0x0D60,0x0000,0x0005,0x6350, + 0x0AA0,0x07E6,0x6006,0xBEB0, + 0x0D60,0x0186,0x6005,0x5550, + 0x0AA0,0x0186,0x6106,0xAAB0, + 0x0D60,0x0182,0x4105,0x5550, + 0x0AA0,0x0183,0xC7C6,0xAAB0, + 0x0D60,0x0183,0xC105,0x5550, + 0x0AA0,0x0181,0x8106,0xAAB0, + 0x0D60,0x0181,0x8005,0xF7D0, + 0x0AB0,0x0181,0x8007,0x1C70, + 0x0D50,0x0000,0x000D,0x1450, + 0x0AA8,0x0000,0x001B,0x1C70, + 0x0D56,0x0000,0x0035,0xF7D0, + 0x0AAB,0xFFFF,0xFFEA,0xAAB0, + 0x0D55,0x5555,0x5555,0x5550, + 0x0AAA,0xAAAA,0xAAAA,0xAAB0, + 0x0D55,0x5555,0x5555,0x5550, + 0x0AAA,0xAAAA,0xAAAA,0xAAB0, + 0x0D55,0x5555,0x5555,0x5550, + 0x0FFF,0xFFFF,0xFFFF,0xFFF0, + 0x0001,0x8000,0x0000,0x6000, + 0x0001,0x8000,0x0000,0x6000, + 0x0001,0x8000,0x0000,0x6000, + 0x0003,0x0000,0x0000,0x3000, + 0x0003,0x0000,0x0000,0x3000, + 0x0006,0x0000,0x0000,0x1800, + 0x0006,0x0000,0x0000,0x1800, + 0x000C,0x0000,0x0000,0x0C00, + 0x000C,0x0000,0x0000,0x0C00, + 0x0018,0x0000,0x0000,0x0600, + 0x0018,0x0000,0x0000,0x0600, + 0x0038,0x0000,0x0000,0x0700, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000, + 0x0000,0x0000,0x0000,0x0000 diff --git a/unix/sun/imtool.icon.NEW b/unix/sun/imtool.icon.NEW new file mode 100644 index 00000000..2eff06f0 --- /dev/null +++ b/unix/sun/imtool.icon.NEW @@ -0,0 +1,34 @@ +/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16 + */ + 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0x88D5,0x5555,0x5555,0x5509, + 0xA2BF,0xFFFF,0xFFFF,0xFEA3,0xA260,0x0000,0x0000,0x0523, + 0x88A7,0xFE00,0xFFFF,0xF689,0x8864,0x0200,0xFFFE,0xF509, + 0xA2A7,0xFE00,0xF80F,0xB6A3,0xA260,0x0000,0xEBFF,0xF523, + 0x88A0,0x1FFF,0xF7E1,0xF689,0x8860,0x1000,0xF61E,0xF509, + 0xA2A0,0x17FE,0xF6FD,0x36A3,0xA260,0x1000,0xE6FF,0xB523, + 0x88A0,0x17FF,0xEE47,0xB689,0x886F,0xF000,0xE711,0xB509, + 0xA2A8,0x17FC,0xB3FD,0x96A3,0xA268,0x1000,0xFBFD,0xD523, + 0x88A8,0x37E0,0xFDB9,0x9689,0x8868,0x7000,0xEEFB,0xB509, + 0xA2A8,0x57FE,0xE607,0xB6A3,0xA268,0x5000,0xFBFF,0x7523, + 0x88A8,0x5400,0xFC6C,0x7689,0x8868,0x5400,0xDFC9,0xF509, + 0xA2A8,0x5000,0xFFFF,0xF6A3,0xA268,0x5000,0x0800,0x0523, + 0x88A8,0x5FFF,0xF800,0x0689,0x8868,0x441D,0x0000,0x7589, + 0xA2A8,0x8275,0x0000,0x56A3,0xA268,0x81C1,0x0000,0x7563, + 0x88A8,0x8081,0x0000,0x06B9,0x886B,0x8001,0x0007,0x750F, + 0xA2A8,0x0001,0x0005,0x56A3,0xA26F,0xFFFF,0x0007,0x7523, + 0x88A0,0x0000,0x0000,0x068B,0x887F,0xFFFF,0xFFFF,0xFD0F, + 0xA2AA,0xAAAA,0xAAAA,0xAAAF,0xA255,0x5555,0x5555,0x5533, + 0x88AA,0xAAAA,0xAAAA,0xAAA9,0x8848,0x8895,0x5548,0x88E9, + 0xA222,0x222A,0xAAA2,0x2263,0xA222,0x2215,0x5562,0x22A3, + 0x8888,0xAAAA,0xAAAA,0x8FFD,0x8888,0x5555,0x5555,0x0DB7, + 0xA222,0xAAAA,0xAAAA,0xADB7,0xA222,0x2222,0x2222,0x2B6F, + 0x8888,0x8888,0x8888,0x9B6D,0x8888,0x8888,0x8888,0x9FF9, + 0xA222,0x2222,0x2222,0x3FFB,0xA222,0x2222,0x2222,0x3FFB, + 0x8888,0x8888,0x8888,0xBFF9,0x8000,0x0000,0x0000,0xBFF9, + 0xA100,0x0000,0x00C2,0x3FF3,0xA000,0x0800,0x0042,0x2223, + 0x830D,0x9E1C,0x3840,0x8889,0x810A,0x8822,0x4440,0x8889, + 0xA10A,0x8822,0x4442,0x2223,0xA10A,0x8822,0x4442,0x2223, + 0x810A,0x8922,0x4440,0x8889,0x810A,0x861C,0x3840,0x8889, + 0xA000,0x0000,0x0002,0x2223,0xA000,0x0000,0x0002,0x2223, + 0x8888,0x8888,0x8888,0x8889,0x8888,0x8888,0x8888,0x8889, + 0xA222,0x2222,0x2222,0x2223,0xFFFF,0xFFFF,0xFFFF,0xFFFF diff --git a/unix/sun/imtool.man b/unix/sun/imtool.man new file mode 100644 index 00000000..f4af4d1c --- /dev/null +++ b/unix/sun/imtool.man @@ -0,0 +1,713 @@ +.\" @(#)imtool.1 1.1 14-Aug-87 DCT +.TH IMTOOL 1 "29 June 1989" +.SH NAME +imtool \- image display server for the SunView environment +.SH SYNOPSIS +.B imtool +[ +.B \-fbconfig \fIN\fP +] +[ +.B \-raster \fIfilename\fP +] +.ti +0.5i +[ +.B \-maptype +\fB\fR(\fPmono \fR|\fP linear \fR|\fP random \fR|\fP crandom\fR) +] +.ti +0.5i +[ +.B \-\fR[\fPno\fR]\fPcolorbar\fR +] +[ +.B \-white \fR|\fP \-black\fR +] +[ +\fIframeargs\fR +] +.SH OPTIONS +.TP +\fB\-fbconfig \fIN\fP +Specifies the initial frame buffer configuration (specifying the number and +size of the internal frame buffers) for the server. +The set of acceptable frame buffer configurations is defined in a private +or public \fIimtoolrc\fR file (discussed below). +.TP +\fB\-raster \fIfilename\fP +Specifies that the server is to start up with the image in the standard +Sun raster format file \fIfilename\fR already loaded into frame buffer 1. +The size of the specified raster need not match the size of the frame +buffer configuration specified with the \fI\-fbconfig\fR argument. +.TP +\fB\-maptype \fR(\fPmono \fR|\fP linear \fR|\fP random \fR|\fP crandom\fR)\fP +Specifies the type of greyscale mapping to be used. +\fBmono\fR means render the image in black and white (shades of gray). +\fBlinear\fR means render the image in linear pseudocolor, with the range of +displayed pixel values corresponding to a range of colors from black to blue +to green to red to white. +\fBrandom\fR means render the image in random pseudocolor, with a random +color being assigned to each greyscale value. +\fBcrandom\fR means render the image in random pseudocolor, updating the +colortable every second or so while the mouse is in the display window. +.TP +\fB\-\fR[\fPno\fR]\fPcolorbar\fR +Specifies whether or not a colorbar is to be displayed at the bottom of the +display window. The colorbar graphically illustrates the relationship between +pixel intensity and displayed color or greylevel, and is particularly useful +with pseudocolor, or when windowing the display. The minimum pixel intensity +(1) is at the left and the maximum (200) is at the right. +.TP +[\fB\-white\fR |\fP \-black\fR] +Specifies whether the image is to be displayed on a white (default) or black +background. +.TP +[\fIframeargs\fR] +\fIimtool\fR also takes generic tool arguments, used to set the position, +size, etc. of the display window; see \fIsuntools\fR(1) for a list of these +arguments. +.if t .sp 0.08i +.SH DESCRIPTION +.SS Image Display Server +.LP +\fIimtool\fR implements a simple image display server for the SunView window +environment. The server runs as an independent process, managing the display +window and listening for connections on a pseudodevice entry in \fB/dev\fR. +All communications with the server are via a simple data stream protocol +described below. +.if t .sp 0.05i +.SS Prototype Status +.LP +The current implementation of the imtool image display server is a limited +prototype, and can be expected to change substantially in the future as the +prototype continues to evolve. The main capabilities lacking in the current +version are flexibility in lookup table control, overlaid graphics and text, +miscellaneous functions such as split screen, and a fully interactive interface +to applications programs. +.if t .sp 0.05i +.SS Basic Concepts +.LP +The display server consists of a set of N \fBframe buffers\fR and a single +\fBdisplay window\fR. A frame buffer is a two dimensional array in memory +into which the image to be displayed is loaded, and which is used to refresh +the display window when portions of the window are uncovered. +In the current prototype display server only 8 bit deep frame buffers are +supported, but the number and size of the frame buffers is user configurable. +.PP +The display window is literally a window into the image stored in the frame +buffer. While the size of the frame buffer is fixed (subject to periodic +reconfiguration), the display window may be any size, and the size may be +changed at any time without affecting the contents of the frame buffer. +Likewise, the position of a small display window upon a larger frame buffer +is arbitrary and may be changed at any time by \fBpanning\fR the window +across the image. While there may be multiple frame buffers, there is only +a single display window, and only a single image may be displayed at any one +time, although a single keystroke suffices to change the frame being viewed. +.PP +With few exceptions, all display server functions are both \fIindependent\fR +and \fIasynchronous\fR. Hence, one can display one frame while another is +being loaded, or even resize or pan the display window and adjust the greyscale +mapping of a frame while the frame is being loaded. +.PP +The primary function of the display server is to provide image display and +interactive image oriented user interface capabilities to a concurrently +executing client program via a bidirectional datastream interface. +Hence, to make use of the display server for image display one also needs an +applications program capable of talking to the server, and sending it image +data to be displayed (a rudimentary builtin capability for displaying Sun +raster files is however provided). The \fBdisplay\fR program in the IRAF +\fBimages.tv\fR package is an example of such a client program. +.if t .sp 0.05i +.SS The Frame Menu +The imtool frame menu provides the following selections: +.if t .sp .05i +.if n .sp +.RS +.IP \fBFrame\fR 15 +Displays the standard SunView frame menu. +.IP \fBSetup\fR +Displays (or hides) the imtool interactive setup panel. +.IP \fBRegister\fR +Adjusts the pan offset of all frame buffers to match that of the image +currently being displayed. Normally, the individual frame buffers are +independently panned. +.IP "\fBBlink \fR[\fPon\fR|\fPoff\fR]" +Turns frame blink (alternate display of a series of frames) on or off. +Alternatively the \fBctrl/B\fR key may be used to manually cycle through +the blink frames. +.IP \fBFitFrame\fR +Adjusts the size of the display window to display the entire frame buffer. +.IP \fBNextFrame\fR +Displays the next frame buffer in sequence. +Used to cycle through and alternately display all frames +(the \fBalternate\fR or \fBctrl/F\fR and \fBctrl/R\fR keys may also be used +to cycle forward or reverse through the frames). +.IP \fBGclear\fR +Clear the graphics overlay of the frame currently being displayed. +.IP \fBIclear\fR +Clear the image, i.e., frame buffer, currently being displayed. +.IP \fBImcopy\fR +Make a hardcopy of the image window. +.RE +.if t .sp .05i +.if n .sp +.LP +The image hardcopy output function is an entry point to the general screen +capture facility, discussed in the next section. This is the same facility +used by the \fIgterm\fR program. +.if t .sp 0.05i +.SS Hardcopy Output +.LP +The image hardcopy function produces a "what you see is what you get" bitmap +of the rectangular region of the screen occupied by the display window. +If the region of interest is partially covered by another window, then the +hardcopy will be a picture of a partially covered window. Any interactive +adjustment of the grayscale mapping will be reflected in the hardcopy output. +.LP +The screen capture software reads out the full memory of the workstation in +the region of interest, and in the case of a color workstation, processes the +screen pixels through the colortable to produce an image corresponding to what +appears on the screen. No full color output options are currently provided, +hence the average of the red, green, and blue color values is next computed. +If rasterfile output is being generated, the raw pixel values and RGB color +table entries are saved directly in the rasterfile, rather than applying the +tables in software to produce a monochrome or bitmap image. +.LP +Two output options are currently provided, i.e., \fBPostscript\fR output +suitable for output directly to a laser writer to produce the final graphics +hardcopy, or \fBSun rasterfile\fR output. The default action is to output a +Postscript program to the device "lw", e.g., the Apple Laserwriter +(any 300 dpi Postscript device should do), using the dithering capability of +Postscript to produce a pseudogreyscale representation of the 8 bit output +image. These defaults may be changed by defining the following environment +variables: +.IP R_RASTERFILE +If this variable is defined a Sun rasterfile will be generated, otherwise a +Postscript plotfile is generated. The string value of the variable is a +\fIprintf\fR style format string to be used to generate the filename of +the rasterfile. If multiple rasterfiles are to be generated, the format +string may contain a decimal integer field (e.g., "\fLframe.%d\fR") to be +replaced by the \fIfile number\fR of the current rasterfile. The first file +generated will be number zero, with the file number being incremented once +for every rasterfile produced. If Postscript plotfile output is desired, +the plotfile will be a uniquely named temporary file in \fB/tmp\fR. +(Postscript output is text and you can read this file if you are curious what +it looks like). +.IP R_DISPOSE +The string value of this variable is a \fIprintf\fR style format string with +one string valued subfield to be replaced by the plotfile or rasterfile name, +to be used to generate the command used to dispose of the output file. +If this variable is not defined and the output file is a Postscript plotfile, +the default format string \fL"lpr -Plw -r -s %s"\fR will be used. +If the variable is not defined and the output file is a rasterfile, +no action is taken. It is the responsibility of the dispose command to +delete the output file. +.LP +It should only take several seconds to capture the screen and produce the +output rasterfile or queue the Postscript job to the printer. The screen +is flashed to indicated when the operation has completed (provided the user +has not turned off the \fIvisible bell\fR feature in their SunView defaults +startup file). +.PP +The Postscript processing time is usually several minutes (of laserwriter time). +Since most Postscript printers are interfaced via a serial interface at 9600 +baud, data compression is used to reduce the amount of data to be transmitted, +and the current bottleneck is the processing speed of the Postscript engine +itself, which does all the dithering and coordinate transformations. +(This is true for bitmaps, but the data compression algorithm used is not +very effective for 8 bit image data, and the serial interface can still be +a bottleneck in this case). +.if t .sp 0.05i +.SS The Setup Panel +.LP +The setup panel is used to interactively modify imtool options. +Two types of selections are provided, \fImultiple choice\fR selections, +and \fIpush button\fR selections. Clicking on a multiple choice selection +cycles through the choices (left mouse button) or displays the choices as +a menu (right mouse button). +String valued options are modified by clicking on the old value, rubbing out +all or part of the old value if necessary, and then typing in a new value +followed by return. If there several string valued fields in a panel, +return may be used to cycle through the fields. +Clicking on a push button (use the left mouse button) "pushes" the button, +causing the action indicated on the button to be executed. +.LP +The multiple choice options in the setup panel are the following: +.IP "\fBNumber of frame buffers\fR" +Specifies the number of frame buffers for which space is currently allocated. +The number of frame buffers may be changed at any time. If a client program +references a frame which does not yet exist, the number of frame buffers will +automatically be increased, hence it is not necessary to preallocate space +for the frame buffers. +.IP "\fBGreyscale mapping\fR" +Specifies the method to be used to map pixel intensity values to RGB color +intensity values. +\fBmono\fR specifies that the image is to be rendered in shades of grey. +\fBlinear pseudocolor\fR specifies that the image is to be rendered in +pseudocolor, with pixel intensities mapped into the range of colors from +black to blue to green to red to white. +\fBrandom pseudocolor\fR assigns a random color to each possible pixel +greylevel. +\fBcontinuous random pseudocolor\fR is like random pseudocolor, +but the colors are changed every few seconds, where the interval +between color changes is specified by the \fBrate\fR option below. +.IP "\fBRate (sec) for Crandom Option\fR +Specifies the frequency (1 to 32 seconds) with which new colors are to be +assigned for the continuous random pseudocolor option. +.IP "\fBBackground color\fR +Specifies the frame background color, i.e., the color to which the frame +will be set when cleared (black or white), or when displaying an image which +fills only part of the frame, the color of the portion of the frame buffer +which has not been written into. +.IP "\fBInclude Frame Border in Imcopy\fR +Specifies whether the frame border, including the frame label, is to be +included in image hardcopies. By default the frame border is included since +the frame label is often used to identify the displayed image. +If the frame border is excluded then so is the colormap, if any. +.IP "\fBShow colorbar\fR +Specifies whether or not a colorbar is to be shown at the bottom of the +display window. +.IP "\fBBlink rate (sec)\fR +When blink is enabled, specifies the amount of time a single frame is to +be displayed. The value may range from 1/2 second to 32 seconds. +The maximum blink rate may be achieved by holding down the \fBalternate\fR +key long enough to cause autorepeat. +.IP "\fBFrames to be blinked\fR +The string value of this parameter specifies the list of frames to be blinked. +The special value "all" may be specified to blink all frames in sequence. +If the frames are explicitly listed, the same frame may appear in the list +multiple times. +.IP "\fBZoom factors\fR +Specifies the positive integer zoom factors to be used for the zoom and pan +function. Up to eight zoom factors may be specified (more would +be undesirable due to the time required to cycle through the zooms to get +back to an unzoomed image). The default zoom factors are "1 2 4 8"; +depending upon the application, one might want to add, e.g., a zoom factor +of 3, or a large zoom factor of 32 or 64 to make it easy to identify +individual pixels. +.IP "\fBCoordinate list output file\fR +Specifies the name of the file to be used for cursor lists (text files +containing lists of object coordinates - see below). +.IP "\fBRaster filename (load/save)\fR +Specifies the filename of the Sun rasterfile to be loaded into the current +frame buffer (\fBload\fR push button, below), or the filename into which +to current frame is to be written (\fBsave\fR push button). +.LP +The following "push buttons" are also provided in the setup panel. +Many of these are equivalent to the comparable selections in the frame menu. +.RS +.IP "\fBRegister Frames\fR" 15 +Adjust the pan offset of all frames to match that of the current frame. +.IP "\fBFit Window\fR" +Adjust the size of the display window to match that of the frame buffer. +.IP \fBReset\fR +Reset the display. The mapping type, transfer function, and pan offsets are +restored to their initial values, but the contents of the frames are not +affected. +.IP \fBIclear\fR +Clear the frame buffer currently being displayed. +.IP \fBGclear\fR +Clear the graphics overlay (may also be cleared whenever the display window +is refreshed). +.IP \fBLoad\fR +Load the Sun rasterfile named by the \fIRaster filename\fR panel string +parameter into the frame buffer currently being displayed. +If the rasterfile is smaller than +the frame buffer the raster will be loaded into the upper left corner of +the frame buffer. If the rasterfile is larger than the frame buffer part of +the raster will be discarded. Any colortable information present in the +rasterfile is ignored. +.IP \fBSave\fR +Save the contents of the frame buffer currently being displayed in the +Sun rasterfile named by the \fIRaster filename\fR panel string parameter. +The new raster will be the same size as the frame buffer. No colortable, +WCS, or any information other than the pixel values is saved in the rasterfile. +.IP \fBBlink\fR +Turn frame blink on or off. +.IP \fBFrame\fR +Display the next frame in sequence. Equivalent to the \fBNextFrame\fR frame +menu selection, and to the \fBalternate\fR and \fBctrl/F\fR keys. +.IP \fBQuit\fR +Close the setup panel. +.RE + +.if t .sp 0.05i +.SS Function Keys +.LP +The following function keys have special significance to \fIimtool\fR: +.RS +.IP F4 15 +Calls up the setup panel, or closes it if already displayed. +.IP F5 15 +Causes the current cursor list file to be rewound and reread, marking all +objects on the cursor list by drawing a number beside each object in the +display window. Each object is marked by its ordinal number in the cursor +list, ignoring comment lines and blank lines. The precise object position +is at the lower left corner of the first digit. +Each time the cursor list is redrawn the color of the digits toggles between +black and white, making it possible for the user to manually "blink" the +object numbers, or select the representation which provides the best visibility +for their data. Note that objects are marked only in the display window, +i.e., the frame buffer is not modified, hence the numerals will be lost +whenever the display is refreshed. +.IP F6 +Enables and disables \fBcursor readout mode\fR. While cursor readout mode is +in effect a box is displayed in the lower right corner of the display window, +in which the coordinates and corresponding pixel intensity at the position of +the the mouse cursor are continuously updated as the mouse is moved. +The cursor coordinates are given in \fIworld coordinates\fR if a WCS (world +coordinate system) has been defined for the frame, otherwise display window +relative pixel coordinates and display pixel intensity values are given. +If the pixel intensity is saturated (set to the extreme high or low value), +a + or - is appended to the printed value to flag the value as saturated. +.IP F7 +Hitting this key while the mouse is in the display window causes an image +hardcopy to be generated. This is equivalent to selecting the \fBimagecopy\fR +item in the frame menu, except that it can be done without moving the mouse. +This may be important to avoid changing the greyscale mapping, which also +depends upon the mouse position. +.RE +.LP +Note that the mouse must be in the display window for these function keys to +have any effect. +.if t .sp 0.05i +.SS Mouse Buttons +.LP +The mouse buttons are used with \fIimtool\fR as follows: +.RS +.IP "Left Button" 15 +In cursor readout mode, used to mark objects, adding each object to the cursor +list for the current frame. Ignored when not in cursor readout mode. + +.IP "Middle Button" +The middle button on the mouse is the \fBpan/zoom\fR button. +If the pan button is held down and released at a position in the display +window, the object under the cursor will be moved to the center of the +display. \fBcontrol-pan\fR is the same except that the image will pan +smoothly to the new position, rather than all at once. \fBshift-pan\fR +causes the image to be panned in the indicated direction in large steps. +Shift and control may be combined to smoothly pan in large steps. +.IP +The \fBzoom\fR function is also controlled by the middle mouse button. +Placing the mouse on an object and pressing pan/zoom once causes the object +to be moved to the center of the display; pressing the button again causes +the image to be zoomed about the mouse position. Repeated presses without +moving the mouse cycle through the predefined set of zoom factors until the +cycle wraps around and the unzoomed image is restored. Zoom is almost as +fast as a normal unzoomed window refresh, so there is no problem with, +for example, panning on a zoomed image. +.IP +If the middle button is held down while in cursor readout mode the mouse may +be moved without updating the displayed cursor coordinates. This is useful +when moving the mouse to a different window, e.g., to type the displayed +object coordinates into an application running in some other window. +An attempt to pan while already at the edge of the frame is ignored. +.IP "Right Button" +Used to interactively adjust the greyscale mapping (colortable) for the window. +.RE +.LP +To window the display, i.e., adjust the \fBtransfer function\fR for the +window, hold the right mouse button down and move the cursor about within the +window. Zero contrast (one greylevel) is at the center of the window, +with positive contrast above, negative contrast below, +and contrast increasing the further the mouse is moved from the centerline. +Moving the mouse to the left or right adjusts the greyscale range to lower +or higher intensities. The colorbar provides a graphic display of the effect +of the transfer function. If the right mouse button is pressed and then +released without moving the mouse the transfer function will be adjusted +according to the position of the mouse. By alternately displaying several +frames and tapping the right mouse button for each frame without moving the +mouse, the transfer functions of several frames may be matched. +.if t .sp 0.05i +.SS Frame Buffer Configuration Files +.LP +While the prototype display server does support dynamic reconfiguration of +the frame buffers, allowing multiple frame buffers of virtually any size, +it is currently necessary to define the possible frame buffer configurations +at startup time. This is done via a table file called the \fBimtoolrc\fR +file. An example illustrating the contents of such a file is shown below. +Note that this may differ from the default configuration file used at your +site. +.sp +.nf + 1 2 512 512 # imt1|imt512 + 2 2 800 800 # imt2|imt800 + 3 2 1024 1024 # imt3|imt1024 + 4 1 1600 1600 # imt4|imt1600 + 5 1 2048 2048 # imt5|imt2048 + 6 1 4096 4096 # imt6|imt4096 + 7 1 4096 1024 # imt7|imt4x1 + 8 1 1024 4096 # imt8|imt1x4 + 9 2 1144 880 # imt9|imtfs full screen (1152x900 minus frame) + 10 2 1144 764 # imt10|imtfs35 full screen at 35mm film aspect ratio + 11 2 128 128 # imt11|imt128 + 12 2 256 256 # imt12|imt256 + + 20 2 388 576 # imt20|imtgec GEC CCD detector format + 21 1 3040 976 # imt21|imtkpca KPCA detector format (also 2D-Frutti) + 22 1 128 1520 # imt22|imt2df1 2D-Frutti + 23 1 256 1520 # imt23|imt2df2 2D-Frutti + 24 1 512 1520 # imt24|imt2df5 2D-Frutti + 25 1 960 1520 # imt25|imt2df9 2D-Frutti + 26 1 512 800 # imt26|imtcryo Cryogenic Camera + 27 1 348 800 # imt27|imtgcam Gold Camera + 28 1 976 3040 # imt28|imt2df9x3 2D-Frutti +.fi +.LP +Each entry in the file contains four numbers, the configuration number +(e.g., as used in \fI\-fbconfig N\fR), the number of frames to be created +initially (frames may be added or deleted once the configuration is +specified), and the width and height of the frame in screen pixels. +Blank lines and comments are ignored. +Note that \fIthe frame width must evenly divisible by 4\fR, +due to alignment restrictions on memory pixrects in SunView. +.LP +Selection of the frame buffer configuration to be used is done at run time +by the client application program when a frame is loaded. Since the frame +buffer size to be used is controlled by the client application program rather +than by the server, there is no entry in the setup panel for changing the +configuration. Rather, it is expected that a command will be provided +at the applications level for specifying the frame buffer size to be used. +In the case of IRAF, this is done with a command such as +\fBreset stdimage = imt800\fR, where the logical device name used on the right +is given in the comments in the configuration table above, and must +correspond to an equivalent entry in the IRAF \fBgraphcap\fR file. +The imtoolrc file may be customized by the user for special applications, +if desired, but a custom version of the graphcap file will be required too. +.LP +The frame buffer configuration file may be located in a default public +directory, e.g., \fB/usr/local/lib/imtoolrc\fR, or the user may have a +private version of the file, e.g., \fB.imtoolrc\fR. During startup, imtool +looks first for an environment variable IMTOOLRC defining the pathname of +the imtoolrc file, then it checks for a .imtoolrc file in the user's login +directory, and finally it checks for the file /usr/local/lib/imtoolrc. +If none of these are found, a default configuration of a single 512 square +frame buffer is used. +.if t .sp 0.05i +.SS World Coordinate Systems +.LP +\fIimtool\fR provides a simple mechanism for associating a linear \fBworld +coordinate system\fR (WCS) with the displayed image. A WCS consists of an +image title string to be displayed in the frame label, a rotation matrix +expressing the translation from window pixel coordinates (zero-indexed, origin +in the upper left corner of the display window) to \fIworld coordinates\fR, +e.g., the image pixel coordinates of the displayed image, and a pair of +image intensity values defining the transformation between display server +pixel intensity units (range 1-200 currently) and image pixel intensity units. +.LP +The WCS for a frame is passed to imtool as a set-WCS command in the datastream +input from the client process (applications display program). +A sample WCS descriptor is shown below. +.if t .sp 0.03i +.if n .sp +.RS +.nf +dev$pix - m51 B 600s +.br +1. 0. 0. -1. 1. 512. 0. 1481.635 1 +.fi +.RE +.if t .sp 0.03i +.if n .sp +.LP +The first line is simply a line of text to be displayed in the frame label +when the WCS is read. This should normally contain the name of the image +and a few words describing the image being displayed. +.LP +The first six numbers in the second line define a rotation matrix specifying +the translation from window pixel coordinates to world coordinates, according +to the following relations: +.if t .sp 0.03i +.if n .sp +.RS +.nf +x' = ax + cy + tx +.br +y' = bx + dy + ty +.fi +.RE +.if t .sp 0.03i +.if n .sp +The coefficients of the transformation matrix are given in the order +\fBa b c d tx ty\fR. The example defines the image pixel coordinates for a +512 square image, displayed with the origin at [1,1] in the lower left corner +of the display window. Note that the world coordinates are flipped in Y +and shifted to an origin at [1,1]. +.LP +The final three numbers on the second line define the transformation from +display pixel intensity units to image pixel intensity units. The first two +values specify the image pixel intensities corresponding to display pixel +intensities 1 and 200. The third number is an integer defining the type +of transformation used; currently the value must be 1, indicating a linear +transformation. +.LP +The WCS is initially undefined when a new frame is created. +The first cursor or function key event thereafter +which attempts to use WCS information will cause the WCS information to be +interpreted if it has been passed in via the set-WCS datastream command. +You will know if the server succeeds in reading the WCS because the +\fBframe label\fR will change when the WCS is read. +The first field of the frame label is the frame name, which will be the +filename of any cursor list files created for the frame. +.if t .sp 0.05i +.SS Coordinate List Files +.LP +Cursor readout mode provides a convenient means of displaying the cursor +coordinates, but the coordinates are lost as soon as the cursor is moved. +To permanently record the positions of objects of interest one may generate +a \fIcoordinate list file\fR by marking objects with the mouse. +The contents of existing list files may also be displayed, and one may append +to an existing list. List files generated by foreign programs may easily +be displayed. +.LP +A coordinate list file is a simple text file with the X-Y coordinate pairs of +objects recorded on successive lines in the file. +The object number is not recorded explicitly, but is determined by the +relative position of a coordinate pair within the file, ignoring comment +lines (#...) and blank lines. List files may be edited and redisplayed if +desired, and although the object numbers may change they will always agree +with whatever is shown on the screen. A hardcopy of the screen may be made +to provide a pictorial record of the contents of a list file, e.g., so that +objects may be referred to by number if the list is used as input to another +program. +.LP +The filename of the list file associated with the displayed frame is shown in +the frame label, e.g., "frame.1". By default the list file will be created +in the WCSDIR, i.e., in the directory defined by the user environment variable +WCSDIR. +.PP +These defaults may be overridden by entering via the setup panel the +\fIprintf\fR style format string to be used to construct the filename of the +list file. If the name given begins with a / an absolute pathname is assumed +and the filename is not modified in any way. Otherwise, a directory prefix +is prepended, e.g., "$wcsdir/frame.\fIN\fP". +The directory prefix is specified by the value of the WCSDIR environment +variable if defined, otherwise the user's UNIX login directory is assumed. +The frame number will appear in the generated filename only if a numeric +format is included in the format string, e.g., \fBframe.%d\fR to specify +a frame number file extension. +.if t .sp 0.05i +.SS Colortable Usage +.LP +To permit simultaneous viewing of both the display window and any other +windows under SunView, \fIimtool\fR uses only a portion of the 256 element +hardware colortable. Image pixels range in value from 1 to 200 (colortable +entry 0 is reserved for the background or foreground color by SunView). +Additional colortable entries are used for the cursor color and a set of +graphics overlay colors, reserving 50 or so colortable entries for use by +other windows. The graphics colortable entries are in the range 202-217. +These are assigned predefined colors, which are unaffected by windowing the +display. The graphics colortable assignments are summarized below. +.if t .sp 0.03i +.RS +.nf +202 black 206 blue 210 coral 214 orchid +203 white 207 yellow 211 maroon 215 turquoise +204 red 208 cyan 212 orange 216 violet +205 green 209 magenta 213 khaki 217 wheat +.fi +.RE +.if t .sp 0.03i +.PP +When imtool is started it reads the hardware color table, which is assumed to +contain the entries for the other windows on the screen, replaces entries +1 through 200+, and uses the resultant table to update the hardware colortable +thereafter at a rate of twice a second. It is necessary to continuously +update the hardware colortable to permit image display while the mouse is not +in the display window, however, this scheme will cause colortable conflicts +f one attempts to run a second window tool which also uses a large number of +colortable entries. +.if t .sp 0.05i +.SS Hints for Blinking Frames +.LP +Blink is most effective when used to compare two or more frames which are very +similar, e.g., a frame and an edited version of the same frame. For blink to +be most effective the images should be displayed as similarly as possible. +Start by loading the two frames using the same spatial and greyscale +transformation for both frames (IRAF users should use the \fBrepeat\fR +option to the \fIdisplay\fR task). Select one of the frames and adjust the +window size, pan offset, and greyscale mapping as desired. After adjusting +the greyscale with the mouse, repeatedly hit the \fBalternate\fR key followed +by the right mouse button to match the greyscale mapping of the first frame to +the remaining frames. Then select \fBregister\fR in the frame menu or setup +panel to register all the frames, followed by \fBblink\fR to blink the frames. +Blink works best if the display window is not too large, e.g., a 400 or 500 +pixel square window is fine. +.if t .sp 0.05i +.SS Data Stream Protocol +.LP +The display server is started like any other SunView tool by executing the +\fIimtool\fR command either directly or indirectly via the \fB.suntools\fR +file or via the mouse from the \fBrootmenu\fR. When first started a checkered +test pattern is displayed, and the display server opens the pseudodevice +files \fB/dev/imt1o\fR (used by the client to send commands and data to the +display server) and \fB/dev/imt1i\fR (for data read back from the display +server) and begins listening for commands from client programs. +All commands and data are passed to the display server as a data stream by +applications writing directly to /dev/imt1o. +.LP +The data stream protocol used +in the prototype server (this will change) mimics that of the IIS Model 70 +image display, with an extension added for specifying the frame buffer +configuration to be used. The server will automatically sense if the +datastream is byte swapped, allowing use of the server with, for example, +IRAF running on a large VAX compute server. Only byte packed data is +supported. +.LP +Note that any process may write to the server, but if more +than one process writes to the server at the same time, the output may be +garbled. Also, multiple display servers may be spawned, but since only a +single pseudodevice entry is currently supported, all such servers would be +trying to read from the same input stream. +.SH SEE ALSO +suntools(1), gterm(1), images.tv.display(IRAF) +.br +\fIWindows and Window-Based Tools: Beginner's Guide\fR +.SH ENVIRONMENT +.IP IMTOOLRC 15 +The full pathname of the \fIimtoolrc\fR (frame buffer configuration) file +to be used (optional). +.IP WCSDIR +The full pathname of the user directory +into which imtool will write any files it creates that are +not specified by a full pathname (alias \fBwcsdir\fR also permitted). +.IP R_RASTERFILE +If defined, a Sun rasterfile rather than Postscript file is generated by +the \fIimcopy\fR function. The string value is a format used to generate +the filename of the rasterfile. +.IP R_DISPOSE +The command to be executed to dispose of the Sun rasterfile or Postscript +output file created by \fIimcopy\fR. If not defined and Postscript output is +indicated (R_RASTERFILE also not defined), then the Postscript output file +is disposed of via \fIlpr\fR to device \fIlw\fR. +.SH FILES +.LP +.nf +/dev/imt1[io] +$WCSDIR/frame.* +/usr/bin/suntools +/usr/lib/rootmenu +$iraf/local/sun/imtool.c +.fi +.SH BUGS +.IP (1) +The display server is continuously updating the hardware colortable even while +the mouse is not in the display window. This is necessary to be able to see +the image while the mouse is not in the window, but may interfere with other +windows which also use many colortable entries. Under normal circumstances +(only one greyscale window) this should not be a problem. If it is a problem, +close the display window when not in use; updating of the hardware colortable +is disabled while the display window is closed. +.IP (2) +Only a single display server should be used at any one time. +Only a single client process should write to the server at any one time. +.IP (3) +The environment variables affecting IMTOOL operation must be defined before +starting suntools if they are to have any effect. +.IP (4) +An error message is printed if imtool encounters a bad data header checksum, +e.g., if synchronization is lost on the input datastream or if illegal data +is input. Recovery from such an error can be difficult, possibly requiring +killing the imtool and starting a new one. This error should not occur if the +software (i.e., the client applications program) is functioning properly. +.SH AUTHOR +Doug Tody, National Optical Astronomy Observatories (NOAO), IRAF project. diff --git a/unix/sun/imtool.square b/unix/sun/imtool.square new file mode 100644 index 00000000..cb54f6eb --- /dev/null +++ b/unix/sun/imtool.square @@ -0,0 +1,4 @@ +/* Format_version=1, Width=16, Height=16, Depth=1, Valid_bits_per_item=16 + */ + 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x03C0,0x03C0, + 0x03C0,0x03C0,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000 diff --git a/unix/sun/imtoolrc b/unix/sun/imtoolrc new file mode 100644 index 00000000..b20a9544 --- /dev/null +++ b/unix/sun/imtoolrc @@ -0,0 +1,48 @@ +# IMTOOL -- Defined frame buffer configurations. Note that the given nframes +# is only a starting point, and may be modified during execution, hence smaller +# values are preferred. The configuration numbers may be given in any order, +# but must be unique and in the range 1-128. NOTE - corresponding entries must +# be present in the dev$graphcap file, for use with IRAF. +# +# Format: configno nframes width height + + 1 2 512 512 # imt1|imt512 + 2 2 800 800 # imt2|imt800 + 3 2 1024 1024 # imt3|imt1024 + 4 1 1600 1600 # imt4|imt1600 + 5 1 2048 2048 # imt5|imt2048 + 6 1 4096 4096 # imt6|imt4096 + 7 1 4096 1024 # imt7|imt4x1 + 8 1 1024 4096 # imt8|imt1x4 + 9 2 1144 880 # imt9|imtfs full screen (1152x900 minus frame) +10 2 1144 764 # imt10|imtfs35 full screen at 35mm film aspect ratio +11 2 128 128 # imt11|imt128 +12 2 256 256 # imt12|imt256 +13 2 128 1056 # imt13|imttall128 tall & narrow for spectro. +14 2 256 1056 # imt14|imttall256 tall & wider for spectro. +15 2 1056 128 # imt15|imtwide128 wide & thin for spectro. +16 2 1056 256 # imt16|imtwide256 wide & fatter for spectro. + +# Some site specific formats for NOAO. +20 2 388 576 # imt20|imtgec GEC CCD detector format +21 1 3040 976 # imt21|imtkpca KPCA detector format (also 2D-Frutti) +22 1 128 1520 # imt22|imt2df1 2D-Frutti +23 1 256 1520 # imt23|imt2df2 2D-Frutti +24 1 512 1520 # imt24|imt2df5 2D-Frutti +25 1 960 1520 # imt25|imt2df9 2D-Frutti +26 1 512 800 # imt26|imtcryo Cryogenic Camera +27 1 348 800 # imt27|imtgcam Gold Camera +28 1 976 3040 # imt28|imt2df9x3 2D-Frutti +29 1 800 256 # imt29|imtgong Gong Cache Monitor +30 1 256 800 # imt30|imtgong Gong Cache Monitor +31 1 1240 400 # imt31|imtret Reticon CCD detector format +32 2 832 800 # imt32|imtti|imtti2|imtti3 +33 2 544 512 # imt33|imtt5ha|imttek2 +34 1 1056 1024 # imt34|imtt1ka|imtte1k|imtst1k +35 1 2080 2048 # imt35|imts2ka|imtt2kb|imtst2k|imtt2k2 +36 1 2048 2080 # imt36|imtt2ka|imtte2k +37 1 3104 1024 # imt37|imtf3ka|imtfo3k + +# User added formats. (start with #64) +# (add here) + diff --git a/unix/sun/mksuntool.csh b/unix/sun/mksuntool.csh new file mode 100755 index 00000000..0c7a4175 --- /dev/null +++ b/unix/sun/mksuntool.csh @@ -0,0 +1,39 @@ +#! /bin/csh +# MKSUNTOOL -- Configure the suntool subdirectory, used to link the suntools +# executable. (Only used for SunOS versions prior to 4.0). + +# set echo + +unset noclobber +unalias cd cmp echo ln mv rm sed set + +set OBJS = "imtool.o gterm.o gtermio.o screendump.o arrow.o notify_read.o" +set sundir = /usr/src/sun/suntool + +if (! -e ./suntool) then + mkdir suntool +endif +cd suntool + +cmp -s Makefile $sundir/Makefile +if ($status == 0 && `grep gterm basetools.h` != "") then + echo "suntool build directory is up to date" + exit 0 +else if (! -e $sundir/Makefile) then + echo "$sundir not found" + exit 1 +else + echo "rebuilding suntool subdirectory" +endif + +set files = "`ls`" +if ("$files" != "") then + rm -rf * +endif +(cd $sundir; tar -cf - . ) | tar -xpf - +echo '"gterm",gterm_main,' >> basetools.h +echo '"imtool",imtool_main', >> basetools.h +echo '/cmdtool_main/i\' > Temp +echo 'extern imtool_main();\' >> Temp +echo 'extern gterm_main();' >> Temp +sed -f Temp toolmerge.c > Temp2; mv -f Temp2 toolmerge.c; rm Temp diff --git a/unix/sun/mouse.c b/unix/sun/mouse.c new file mode 100644 index 00000000..a7d4b538 --- /dev/null +++ b/unix/sun/mouse.c @@ -0,0 +1,47 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <suntool/sunview.h> + +/* MOUSE.C -- Routines for saving and restoring the mouse position. These + * are used by a window which needs to grab the mouse and set it to a specific + * position, e.g., because the user has entered a command in to another window + * requesting a cursor read by the process running in the current window. + * (It was NOT easy to figure out how to do this in SunView, but at least I + * was able to do it...). + */ + +/* GET_ABSMOUSEPOS -- Get the current position of the mouse in absolute screen + * coordinates. + */ +get_absmousepos (mywinfd, x, y) +int mywinfd; /* any window on current screen will do */ +int *x, *y; /* mouse position (output) */ +{ + struct screen rootscreen; + int rootfd; + + win_screenget (mywinfd, &rootscreen); + rootfd = open (rootscreen.scr_rootname, 0); + + *x = win_get_vuid_value (rootfd, LOC_X_ABSOLUTE); + *y = win_get_vuid_value (rootfd, LOC_Y_ABSOLUTE); + + close (rootfd); +} + + +/* SET_ABSMOUSEPOS -- Set the mouse position in absolute screen coordinates. + */ +set_absmousepos (mywinfd, x, y) +int mywinfd; /* any window on current screen will do */ +int x, y; /* desired mouse position */ +{ + struct screen rootscreen; + int rootfd; + + win_screenget (mywinfd, &rootscreen); + rootfd = open (rootscreen.scr_rootname, 0); + win_setmouseposition (rootfd, x, y); + close (rootfd); +} diff --git a/unix/sun/notify_read.c b/unix/sun/notify_read.c new file mode 100644 index 00000000..b02913c9 --- /dev/null +++ b/unix/sun/notify_read.c @@ -0,0 +1,85 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <syscall.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/uio.h> +#include <stdio.h> + +static int (*u_fcn)(); /* user functions to process read */ +static int u_fd; /* fd to be monitored */ + +/* NOTIFY_READ -- This is a customized version of the SunView 3.2 notify_read + * primitive, the notifier's version of the UNIX read() system call (when + * the notifier is used, read() is a high level function, not a system call). + * The function of this special version of notify_read is to intercept kernel + * read calls made by the notifier for the purposes of monitoring, and + * possibly filtering, low level input from a file descriptor. + */ +notify_read (fd, buf, maxch) +int fd; +char *buf; +int maxch; +{ + register int n; + + /* This is a bit of a kludge, but lacking the shelltool source it + * was difficult to do better. The 18 is the size of the tty packet + * echoed by the driver when a character is typed; this is not part + * of the normal output stream so we exclude these events. The buf+1 + * business is to hide the packet mode nature of the stream from the + * gtermio code; the first byte of each packet indicates the packet + * type. These details could change in a future Sun release in which + * case this code would have to be modified. + */ + if (u_fcn && fd == u_fd && maxch != 18) { + n = syscall (SYS_read, fd, buf, maxch); + if (n > 0 && *buf == TIOCPKT_DATA) + return ((*u_fcn)(buf+1, n-1, maxch-1) + 1); + else + return (n); + } else + return (syscall (SYS_read, fd, buf, maxch)); +} + + +/* READV -- This is a customized version of the readv system call, used in + * the Release 3.4 version of ttysw to read from the pty. Usage is (appears + * to be) identical to the old notify_read, except that the TIOCPKT byte is + * returned separately from the data. + */ +readv (fd, iov, iovcnt) +register int fd; +register struct iovec *iov; +int iovcnt; +{ + register int n; + + if (u_fcn && fd == u_fd && iovcnt == 2 && iov[0].iov_len == 1) { + n = syscall (SYS_readv, fd, iov, iovcnt); + if (n > 0 && *(iov[0].iov_base) == TIOCPKT_DATA) + return ((*u_fcn)(iov[1].iov_base, n-1, iov[1].iov_len) + 1); + else + return (n); + } else + return (syscall (SYS_readv, fd, iov, iovcnt)); +} + + +/* NOTIFY_READ_POST_MONITOR_FCN -- Post a user data monitor/filter function + * to process the input on the specified file descriptor. Only one file + * descriptor can be monitored at present. + */ +notify_read_post_monitor_fcn (fd, fcn) +int fd; +int (*fcn)(); +{ + if (u_fcn && !fcn) + return (-1); + else { + u_fcn = fcn; + u_fd = fd; + return (0); + } +} diff --git a/unix/sun/screendump.c b/unix/sun/screendump.c new file mode 100644 index 00000000..a3582e57 --- /dev/null +++ b/unix/sun/screendump.c @@ -0,0 +1,549 @@ +/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc. + */ + +#include <suntool/sunview.h> +#include <suntool/fullscreen.h> +#include <pixrect/pr_planegroups.h> +#include <stdio.h> +#include <pwd.h> + +#define SEGSIZE 16 /* output segment size (bytes) */ +#define SEGBITS (SEGSIZE*8) +#define BITFLIP 0 /* bit-flip each byte for P.S.? */ +#define NGREY 256 /* max color table size */ +#define PAGE_WIDTH 2550 /* 8.5x11, 300 dpi */ +#define PAGE_HEIGHT 3300 /* 8.5x11, 300 dpi */ +#define PAGE_XOFFSET 0 /* offset to drawing area */ +#define PAGE_YOFFSET 0 /* offset to drawing area */ +#define MARGIN 150 /* 1/2 inch margin */ +#define MAXGROUPS (PIXPG_OVERLAY+1) + +#define RT_DATA 'a' /* record type codes */ +#define RT_ZERO 'b' +#define RT_FULL 'c' +#define RT_BKG1 'd' +#define RT_BKG2 'e' +#define BKGPAT_1 "22" /* atom for stipple pattern */ +#define BKGPAT_2 "88" /* atom for stipple pattern */ + +/* The following are provided by the calling program and specify what type + * of output is desired. + */ +extern int r_type; /* 0=postscript, 1=rasterfile */ +extern char r_dispose[]; /* dispose command */ +extern char r_filename[]; /* output file template */ + +int gt_bitflip_postscript = BITFLIP; +static unsigned char red[NGREY], green[NGREY], blue[NGREY]; +static void bitmap_to_postscript(); +static char *make_label(); + + +/* SCREENDUMP -- Make a hardcopy of the indicated region of the screen on a + * hardcopy device. Currently only two output formats are supported, Sun + * rasterfile output, or Postscript. A dispose command may be given to + * postprocess the output file, e.g., send it to the printer. + */ +screendump (win_fd, pw, width, height, left, top, nbits_out) +int win_fd; /* window fd, for bell */ +struct pixwin *pw; /* arbitrary pixwin, used to lock display */ +int width, height; /* region to be printed: size, */ +int left, top; /* origin */ +int nbits_out; /* output 1 bit or 8 bit postscript image? */ +{ + register int v, i, j; + register unsigned char *ip, *op; + unsigned char *pr_data, *obuf, *zero; + + struct rect pw_r; + struct timeval tv_bell; + struct pixrect *screen, *s_pr, *o_pr, *m_pr; + static int filenum = 0; + + float scale, xs, ys; + int overlay, ngroups; + char groups[MAXGROUPS]; + char tempfile[80], dispose[80]; + int depth, cache_v, cache_greyval, rasterout; + int status=0, bit, byte, pr_linebytes, ob_linebytes, fd; + char *str, *getenv(); + FILE *fp; + + /* Open the hardware frame buffer, create a memory pixrect to hold user + * specified rect, lock the display and read in the data and colormap. + * The Sun 3-110, 3/60, etc., have separate monochrome and color + * planes plus an overlay-enable plane, whereas the older frame buffers + * have only a single monochrome or color plane. + */ + screen = pr_open ("/dev/fb"); + + depth = screen->pr_depth; + ngroups = pr_available_plane_groups (screen, MAXGROUPS, groups); + overlay = (ngroups >= PIXPG_OVERLAY); + + /* Get memory pixrects to hold frame buffer data. */ + zero = (unsigned char *) malloc (height); + s_pr = mem_create (width, height, depth); + if (overlay) { + o_pr = mem_create (width, height, 1); + m_pr = mem_create (width, height, 1); + } + + /* Lock the frame buffer to avoid edits during readout. */ + pw_get_region_rect (pw, &pw_r); + pw_lock (pw, &pw_r); + + /* Get the color map and the main frame buffer pixrect. */ + pr_getcolormap (screen, 0, NGREY, red, green, blue); + pr_set_plane_group (s_pr, PIXPG_8BIT_COLOR); + pr_rop (s_pr, 0, 0, width, height, PIX_SRC, screen, left, top); + + /* If the device has an overlay plane, readout it out as well as the + * enable plane. + */ + if (overlay) { + int o_pg; + o_pg = pr_get_plane_group (screen); + pr_set_plane_group (screen, PIXPG_OVERLAY); + pr_rop (o_pr,0,0, width, height, + PIX_SRC, screen, left, top); + pr_set_plane_group (screen, PIXPG_OVERLAY_ENABLE); + pr_rop (m_pr,0,0, width, height, + PIX_SRC, screen, left, top); + pr_set_plane_group (screen, o_pg); + } + + pw_unlock (pw); + pr_close (screen); + + /* Combine the color plane and overlay plane to produce a single + * color plane. Use only those overlay plane pixels which have their + * bit set in the enable plane. + */ + if (overlay) { + pr_stencil (s_pr,0,0, width, height, + PIX_COLOR(255) | PIX_SRC | PIX_DONTCLIP, m_pr,0,0, o_pr,0,0); + pr_close (m_pr); + pr_close (o_pr); + } + + /* Output can be either Postscript or a Sun rasterfile. Rasterfile + * output is handled here. + */ + if (rasterout = (r_type && r_filename[0])) { + colormap_t cmap; + + /* Setup colormap descriptor. */ + cmap.type = RMT_EQUAL_RGB; + cmap.length = NGREY; + cmap.map[0] = red; + cmap.map[1] = green; + cmap.map[2] = blue; + + /* Open raster file. */ + sprintf (tempfile, r_filename, filenum++); + if ((fp = fopen (tempfile, "w")) == NULL) { + fprintf (stderr, "cannot create %s\n", tempfile); + return (-1); + } + + pr_dump (s_pr, fp, &cmap, RT_STANDARD, 0); + + fclose (fp); + pr_close (s_pr); + goto dispose_; + } + + /* If the frame buffer is only 1 bit deep we can set obuf to point + * to the pixrect data and we are done. Otherwise we must process + * the image pixels through the color table and convert the output + * into a monochrome pixrect. NOTE: the bits may need to be flipped + * in the monochrome pixrect to satisfy Postscript; I wasn't sure. + */ + if (depth == 1) { + /* This option is currently untested. */ + obuf = (unsigned char *) mpr_d(s_pr)->md_image; + ob_linebytes = mpr_d(s_pr)->md_linebytes; + + if (gt_bitflip_postscript) { + unsigned char flip[256]; + + /* Set up lookup table. */ + for (j=0; j < 256; j++) { + for (v=0, i=0; i < 8; i++) + v |= (((j >> i) & 1) << (7-i)); + flip[j] = v; + } + + /* Bitflip and set the zero-line vector. */ + for (j=0; j < height; j++) { + v = 1; + for (op=obuf+j*ob_linebytes, i=ob_linebytes; --i >= 0; ) { + if (v && *op) + v = 0; + *op++ = flip[*op]; + } + zero[j] = v; + } + } else { + /* Set the zero-line vector for the pixrect. */ + for (j=0; j < height; j++) { + v = 1; + for (op=obuf+j*ob_linebytes, i=ob_linebytes; --i >= 0; ) { + if (v && *op) { + v = 0; + break; + } + } + zero[j] = v; + } + } + + } else if (nbits_out == 1) { + ob_linebytes = (width + 7) / 8; + obuf = (unsigned char *) calloc (ob_linebytes * height, 1); + if (obuf == NULL) { + fprintf (stderr, "out of memory\n"); + return (-1); + } + pr_data = (unsigned char *) mpr_d(s_pr)->md_image; + pr_linebytes = mpr_d(s_pr)->md_linebytes; + + for (j=0, cache_v=(-1); j < height; j++) { + ip = pr_data + j * pr_linebytes; + op = obuf + j * ob_linebytes; + + for (byte=(-1), i=0; i < width; i++) { + if ((v = ip[i]) == cache_v) + v = cache_greyval; + else { + cache_v = v; + v = cache_greyval = (red[v] + green[v] + blue[v]) / 3; + } + if (v <= NGREY/2) { + byte = i / 8; + bit = 8 - (i % 8) - 1; + op[byte] |= (1 << bit); + } + } + + /* Set flag if entire line is zero. */ + zero[j] = (byte < 0); + } + + pr_close (s_pr); + + } else if (nbits_out == 8 && depth == 8) { + /* Eight bits out; transform the image in place in the input + * pixrect to save memory. + */ + obuf = pr_data = (unsigned char *) mpr_d(s_pr)->md_image; + ob_linebytes = pr_linebytes = mpr_d(s_pr)->md_linebytes; + + for (j=0, cache_v=(-1); j < height; j++) { + ip = pr_data + j * pr_linebytes; + op = obuf + j * ob_linebytes; + + for (i=0; i < width; i++) { + if ((v = ip[i]) == cache_v) + v = cache_greyval; + else { + cache_v = v; + v = cache_greyval = (red[v] + green[v] + blue[v]) / 3; + } + op[i] = v; + } + + /* Set flag if entire line is zero. */ + zero[j] = 0; + } + + } else { + fprintf (stderr, "can only create 1 bit or 8 bit output image\n"); + return (-1); + } + + /* Create the output file to hold postscript program. If no filename + * has been specified create a unique file in /tmp. + */ + if (!r_filename[0]) { + strcpy (tempfile, "/tmp/psXXXXXX"); + if ((fd = mkstemp (tempfile)) == -1) { + fprintf (stderr, "cannot create temporary file %s\n", tempfile); + return (-1); + } else + fp = fdopen (fd, "a"); + } else { + sprintf (tempfile, r_filename, filenum++); + if ((fp = fopen (tempfile, "w")) == NULL) { + fprintf (stderr, "cannot create %s\n", tempfile); + return (-1); + } + } + + /* Scale to fit output page. */ + xs = (PAGE_WIDTH - MARGIN*2) / (float)width; + ys = (PAGE_HEIGHT - MARGIN*2) / (float)height; + scale = (xs < ys) ? xs : ys; + + /* Translate the bitmap into a postscript program. */ + bitmap_to_postscript (fp, + obuf, width, height, nbits_out, ob_linebytes, zero, scale); + + free ((char *)zero); + if (depth == 1 || (depth == 8 && nbits_out == 8)) + pr_close (s_pr); + else + free ((char *)obuf); + + fclose (fp); + close (fd); + + /* Dispose of tempfile to the printer. We leave it up to the dispose + * command to delete the temporary file when finished. + */ +dispose_: + if (r_dispose[0]) { + sprintf (dispose, r_dispose, tempfile); + if ((status = system (dispose)) != 0) + fprintf (stderr, "screendump: exit status %d\n", status); + } + + /* Flash the screen to signal the user that we are done. */ + tv_bell.tv_usec = 0*1000; tv_bell.tv_sec = 0; + win_bell (win_fd, tv_bell, pw); + + return (status); +} + + +/* BITMAP_TO_POSTSCRIPT -- Translate a memory bitmap into a postscript program + * using image compression where regions of the image are all zeroes. This is + * done as follows: [1] lines of the bitmap are divided into segments of N + * bytes, [2] if all N bytes are zero a single zero byte is transmitted, + * otherwise a byte with the value one is transmitted, followed by N bytes of + * literal data. Lines which are entirely zero are not transmitted at all. + * The goal is to significantly reduce the amount of data to be pushed through + * the laserwriter serial interface while keeping things simple enough that + * postscript will hopefully be able to process the bitmap efficiently. + * + * NOTE: Postscript is supposed to be able to copy bitmaps directly without + * any transformations if all the right conditions are met, e.g., unitary + * matrices, pixrect resolution matches device resolution, etc. We do not + * make use of this here due to the great volume of data which would have to + * pushed through the laserwriter serial interface at 9600 baud to transmit + * a fully resolved bitmap. If a parallel interface were available, e.g., + * if the laserwriter is on the ethernet, then this would be the way to go. + */ +static void +bitmap_to_postscript (fp, bitmap, width, height, depth, linebytes, zero, scale) +register FILE *fp; +unsigned char *bitmap; +int width, height, depth; +int linebytes; +unsigned char *zero; +float scale; +{ + register unsigned char *ip; + register char *op, *hp; + register int n; + unsigned char *segp; + char hbuf[NGREY*2]; + char obuf[SEGSIZE*2]; + char rt_full[SEGSIZE*2+1]; + char bkg_1[SEGSIZE*2+1]; + char bkg_2[SEGSIZE*2+1]; + int partseg, seg, nsegs, allzeroes, i, j, last_j; + + /* Initialize the hbuf array, which contains the hex encoded + * representations of the NGREY possible binary byte values. + */ + for (n=0, op=hbuf; n < NGREY; n++) { + i = ((n >> 4) & 017); + *op++ = (i < 10) ? i + '0' : (i-10) + 'A'; + i = (n & 017); + *op++ = (i < 10) ? i + '0' : (i-10) + 'A'; + } + + /* Set up the background (stipple) pattern arrays, used to represent + * the Sunview background pattern outside of windows. + */ + for (op=bkg_1, hp=BKGPAT_1, n=SEGSIZE; --n >= 0; ) { + *op++ = hp[0]; + *op++ = hp[1]; + } *op++ = '\0'; + for (op=bkg_2, hp=BKGPAT_2, n=SEGSIZE; --n >= 0; ) { + *op++ = hp[0]; + *op++ = hp[1]; + } *op++ = '\0'; + + /* RT_FULL is a solid line, another common pattern. */ + for (op=rt_full, n=SEGSIZE*2; --n >= 0; ) + *op++ = 'F'; + *op++ = '\0'; + + /* Initialize obuf, in case a partseg call causes the full buffer to + * be written out before the garbage elements at the end have been + * initialized to legal values. + */ + bcopy (rt_full, obuf, SEGSIZE*2); + + /* Define the postscript necessary to receive and output the lines + * of the pixrect with image compression. + */ + fprintf (fp, "%%! GTERM screendump\n"); + fprintf (fp, "erasepage initgraphics\n"); + + /* fprintf (fp, "[%6.3f 0 0 %6.3f 2350 3180] setmatrix\n", + -scale, -scale); */ + fprintf (fp, "initmatrix\n"); + fprintf (fp, "%6.3f 72 mul 300 div\n", -scale); + fprintf (fp, "%6.3f 72 mul 300 div scale\n", scale); + fprintf (fp, "%f %f translate\n", 2409/(-scale), (-88)/(-scale)); + + fprintf (fp, "%d %d translate\n", PAGE_XOFFSET, PAGE_YOFFSET); + fprintf (fp, "/r_data %d string def\n", SEGSIZE); + fprintf (fp, "/r_zero %d string def\n", SEGSIZE); + fprintf (fp, "/r_full %d string def\n", SEGSIZE); + fprintf (fp, "/r_bkg1 %d string def\n", SEGSIZE); + fprintf (fp, "/r_bkg2 %d string def\n", SEGSIZE); + fprintf (fp, "currentfile r_full readhexstring %s\n", rt_full); + fprintf (fp, "currentfile r_bkg1 readhexstring %s\n", bkg_1); + fprintf (fp, "currentfile r_bkg2 readhexstring %s\n", bkg_2); + fprintf (fp, "clear\n"); + + if (depth == 8) { + fprintf (fp, + "/dline {0 exch translate %d %d 8 matrix\n", width, 1); + } else { + fprintf (fp, + "/dline {0 exch translate %d %d true matrix\n", width, 1); + } + + fprintf (fp, " { currentfile read pop dup %d eq\n", RT_DATA); + fprintf (fp, " { pop currentfile r_data readhexstring pop }\n"); + fprintf (fp, " { dup %d eq\n", RT_ZERO); + fprintf (fp, " { pop r_zero }\n"); + fprintf (fp, " { dup %d eq\n", RT_FULL); + fprintf (fp, " { pop r_full }\n"); + fprintf (fp, " { %d eq\n", RT_BKG1); + fprintf (fp, " { r_bkg1 }\n"); + fprintf (fp, " { r_bkg2 }\n"); + fprintf (fp, " ifelse }\n"); + fprintf (fp, " ifelse }\n"); + fprintf (fp, " ifelse }\n"); + fprintf (fp, " ifelse\n"); + + if (depth == 8) + fprintf (fp, " } image} def\n"); + else + fprintf (fp, " } imagemask} def\n"); + + nsegs = width / (SEGBITS / depth); + partseg = linebytes - (nsegs * SEGSIZE); + + /* Output successive lines of the pixrect. All zero lines are omitted + * and data compression is used for large regions of zeroes embedded + * within a line. + */ + for (j=0, last_j=0; j < height; j++) { + if (zero[j]) + continue; + + fprintf (fp, "\n%d dline\n", j - last_j); + last_j = j; + + /* Output an integral number of line segments in hexstring format, + * i.e., two hex digits output per binary input byte. + */ + segp = bitmap + j*linebytes; + for (seg=0; seg < nsegs; seg++, segp += SEGSIZE) { + /* Quick scan of the data to see if it is all zeroes. */ + allzeroes = 1; + for (ip=segp, n=SEGSIZE; --n >= 0; ) + if (*ip++) { + allzeroes = 0; + break; + } + + if (allzeroes) { + putc (RT_ZERO, fp); + } else { + /* Encode the data segment in hex format. */ + for (ip=segp, op=obuf, n=SEGSIZE; --n >= 0; ) { + hp = hbuf + (*ip++ * 2); + *op++ = *hp++; + *op++ = *hp++; + } + + if (obuf[0] == rt_full[0] && + strncmp (obuf, rt_full, SEGSIZE*2) == 0) { + putc (RT_FULL, fp); + } else if (obuf[0] == bkg_1[0] && + strncmp (obuf, bkg_1, SEGSIZE*2) == 0) { + putc (RT_BKG1, fp); + } else if (obuf[0] == bkg_2[0] && + strncmp (obuf, bkg_2, SEGSIZE*2) == 0) { + putc (RT_BKG2, fp); + } else { + putc (RT_DATA, fp); + fwrite (obuf, SEGSIZE*2, 1, fp); + } + } + } + + /* Write out any partial segment at the end of the line. We must + * always write a full segment, even if the data at the end is + * garbage, else synchronization will be lost. + */ + if (partseg) { + for (op=obuf, n=partseg; --n >= 0; ) { + hp = hbuf + (*ip++ * 2); + *op++ = *hp++; + *op++ = *hp++; + } + putc (RT_DATA, fp); + fwrite (obuf, SEGSIZE*2, 1, fp); + } + } + + /* Add the NOAO logo and timestamp at the bottom of the page and + * output the page. + */ + fprintf (fp, "\n"); + fprintf (fp, "/Times-Roman findfont 24 scalefont setfont\n"); + + /* fprintf (fp, "[-1 0 0 -1 2350 3180] setmatrix\n"); */ + fprintf (fp, "initmatrix\n"); + fprintf (fp, "-1 72 mul 300 div 1 72 mul 300 div scale\n"); + fprintf (fp, "-2409 88 translate\n"); + + fprintf (fp, "%d %d moveto\n", 1600, 3150); + fprintf (fp, "[1 0 0 -1 0 0] concat\n"); + fprintf (fp, "(%s) show\n", make_label()); + fprintf (fp, "showpage\n"); +} + + +/* MAKE_LABEL -- Generate the label for the output printer page. + */ +static char * +make_label() +{ + static char buf[128]; + char hostname[32]; + char username[32]; + struct passwd *pw; + long clock; + + clock = time(0); + gethostname (hostname, 32); + pw = getpwuid (getuid()); + strcpy (username, pw->pw_name); + endpwent(); + + sprintf (buf, "NOAO/IRAF %s@%s %s", + username, hostname, asctime(localtime(&clock))); + + return (buf); +} diff --git a/unix/sun/ss1.patch b/unix/sun/ss1.patch new file mode 100644 index 00000000..dcd0ce15 --- /dev/null +++ b/unix/sun/ss1.patch @@ -0,0 +1,31 @@ +This is to fix the "chicken scratches" bug that occurs with IMTOOL on a +sparcstation. The problem occurs due to a bug in the SunOS kernel for the +sparcstation. The patch given here is a workaround to avoid the problem +until Sun fixes the bug. + +To patch the imtool executable, login as iraf, then make a backup copy of +the imtool.e executable and patch the online one, as follows (be sure to +get the case of the ?X and ?W right): + + % cd $iraf/unix/bin.sparc + % cp imtool.e imtool.e.OLD + % + % adb -w imtool.e + 0xc2a0?X +* 0xc2a0: ac102018 + 0xc2a0?W0xac10200c +* 0xc2a0: 0xac102018 = 0xac10200c + $q + % + +In the sequence shown above, the lines marked * are adb output. If the old +value of location 0xc2a0 is not ac102018 (hex) as shown, then you have an +old or otherwise unusual version of IMTOOL and the patch should not be +applied. Once the executable has been patched, either copy the new executable +to /usr/bin/imtool (or wherever imtool lives on your system) or rerun the +INSTALL script in $hlib. + +The fix changes the rasterop used to draw the IMTOOL crosshair cursor from +a copy-source-to-destination to an xor-source-and-destination. This results +in a less visible cursor, but avoids the bug that leaves the scratches all +over the IMTOOL window. |