Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2970

Internet Message Format | 1991-03-05 | 54.5 KB

From: [e-mail] (Guido van Rossum)
Newsgroups: alt.sources
Subject: STDWIN 0.9.5, Part 09/19
Message-ID: <[e-mail]>
Date: 4 Mar 91 11:58:02 GMT

Archive-name: stdwin/part09

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 9 (of 19)."
# Contents:  Packs/vt/vtansi.c Ports/alfa/stdwin.c Ports/mac/draw.c
#   Ports/x11/menu.c Ports/x11/timer.c
# Wrapped by [e-mail] on Mon Mar  4 12:37:27 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Packs/vt/vtansi.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Packs/vt/vtansi.c'\"
else
echo shar: Extracting \"'Packs/vt/vtansi.c'\" \(11653 characters\)
sed "s/^X//" >'Packs/vt/vtansi.c' <<'END_OF_FILE'
X/* ANSI escape sequence interpreter */
X
X/* There is some ugly code here, since I assume that code looking
X   at the input a character at a time is very time-critical.
X   Action functions are called with the start of the text to process,
X   and return a pointer to where they left off.
X   When an action function hits the end of the string,
X   it returns NULL and sets the action pointer to the function to
X   call next (often itself), or to NULL for the default.
X   A non-NULL return implies that the default action function must
X   be called next and the action pointer is irrelevant.
X   Remember that the general form of most ANSI escape sequences is
X    ESC [ <n1> ; <n2> ; ... <c>
X   where <c> is the command code and <n1>, <n2> etc. are optional
X   numerical parameters.
X*/
X
X#include "vtimpl.h"
X
X#ifdef DEBUG
X /* Let it be heard that a command was not recognized */
X#define FAIL() wfleep()
X#else
X/* Silently ignore unrecognized commands */
X#define FAIL() 0
X#endif
X
X/* Function prototypes */
X
XSTATIC char *def_action _ARGS((VT *vt, char *text, char *end));
XSTATIC char *esc_action _ARGS((VT *vt, char *text, char *end));
XSTATIC char *ansi_params _ARGS((VT *vt, char *text, char *end));
XSTATIC char *ansi_execute _ARGS((VT *vt, char *text));
XSTATIC void vtsetoptions _ARGS((VT *vt, bool flag));
XSTATIC void vtsetattrlist _ARGS((VT *vt));
X
X/* Output a string, interpreting ANSI escapes */
X
Xvoid
Xvtansiputs(vt, text, len)
X    VT *vt;
X    char *text;
X    int len;
X{
X    char *end;
X
X#ifndef NDEBUG
X    if (vt->scr_top < 0 || vt->scr_top > vt->rows) {
X        fprintf(stderr, "vtansiputs: scr_top = %d\n", vt->scr_top);
X        vtpanic("vtansiputs: bad scr_top");
X    }
X#endif
X
X    if (len < 0)
X        len = strlen(text);
X    end = text + len;
X
X    D( printf("vtansiputs %d chars\n", len) );
X
X    /* Pick up where the last call left us behind  */
X    if (vt->action != NULL)
X        text = (*vt->action)(vt, text, end);
X
X    /* Start in default state until text exhausted */
X    while (text != NULL)
X        text = def_action(vt, text, end);
X
X    /* Execute delayed scrolling */
X    vtsync(vt);
X    D( printf("vtansiputs returns\n") );
X}
X
X/* Default action function */
X
XSTATIC char *
Xdef_action(vt, text, end)
X    VT *vt;
X    char *text, *end;
X{
Xagain:
X    for (;;) {
X        if (text >= end) {
X            vt->action = NULL;
X            return NULL;
X        }
X        if (PRINTABLE(*text))
X            break;
X        switch (*text++) {
X
X        case ESC:    /* ESC */
X            return esc_action(vt, text, end);
X
X        case BEL:    /* Bell */
X            if (vt->visualbell) {
X                VTBEGINDRAWING(vt);
X                vtinvert(vt, 0, 0, vt->rows, vt->cols);
X                VTENDDRAWING(vt);
X                VTBEGINDRAWING(vt);
X                vtinvert(vt, 0, 0, vt->rows, vt->cols);
X                VTENDDRAWING(vt);
X            }
X            else {
X                wfleep();
X            }
X            break;
X
X        case BS:    /* Backspace -- move 1 left */
X            /* Rely on vtsetcursor's clipping */
X            vtsetcursor(vt, vt->cur_row, vt->cur_col - 1);
X            /* Don't erase --
X               that's part of intelligent echoing */
X            break;
X
X        case TAB:    /* Tab -- move to next tab stop */
X            /* Rely on vtsetcursor's clipping */
X            /* TO DO: use programmable tab stops! */
X            vtsetcursor(vt, vt->cur_row,
X                (vt->cur_col & ~7) + 8);
X            /* Normalize cursor (may cause scroll!) */
X            vtputstring(vt, "", 0);
X            break;
X
X        case LF:    /* Linefeed -- move down one line */
X            if (vt->nlcr)    /* First a \r? */
X                vtsetcursor(vt, vt->cur_row, 0);
X            vtlinefeed(vt, 1);
X            break;
X
X        case FF:    /* Formfeed */
X            /* vtreset(vt); */
X            break;
X
X        case CR:    /* Return -- to col 0 on same line */
X            vtsetcursor(vt, vt->cur_row, 0);
X            break;
X
X        case ' ':    /* In case isprint(c) fails for space */
X            vtputstring(vt, " ", 1);
X            break;
X
X        default:
X            D( printf("Unrecognized unprintable character 0x%x\n",
X                                text[-1]) );
X            FAIL();
X            break;
X        }
X    }
X
X    /* We fall through the previous loop when we get a printable
X       character */
X
X    {
X        char *p = text;
X
X        while (PRINTABLE(*++p)) {
X            /* At least one character guaranteed! */
X            if (p >= end)
X                break;
X        }
X        vtputstring(vt, text, (int)(p-text));
X        text = p;
X        goto again;
X    }
X}
X
X/* Action function called after ESC seen */
X
XSTATIC char *
Xesc_action(vt, text, end)
X    VT *vt;
X    char *text, *end;
X{
X    if (text >= end) {
X        vt->action = esc_action;
X        return NULL;
X    }
X    switch (*text++) {
X/*
X    case '(':
X    case ')':
X    case '*':
X    case '+':
X        return cset_action(vt, text, end);
X*/
X    case '=':
X        vt->keypadmode = TRUE;
X        break;
X    case '>':
X        vt->keypadmode = FALSE;
X        break;
X    case '7':
X        vtsavecursor(vt);
X        break;
X    case '8':
X        vtrestorecursor(vt);
X        break;
X    case 'D':
X        vtlinefeed(vt, 1);
X        break;
X    case 'E':
X        /* Next Line */
X        break;
X    case 'H':
X        /* Tab set */
X        break;
X    case 'M':
X        vtrevlinefeed(vt, 1);
X        break;
X    case '[':
X        vt->nextarg = vt->args;
X        *vt->nextarg = -1;
X        vt->modarg = '\0';
X        return ansi_params(vt, text, end);
X    case 'c':
X        vtreset(vt);
X        break;
X    default:
X        D( printf("Urecognized: esc-%c (0x%x)\n",
X                text[-1], text[-1]) );
X        FAIL();
X        break;
X    }
X    return text;
X}
X
X/* Action function called after ESC-[ plus possible parameters seen */
X
XSTATIC char *
Xansi_params(vt, text, end)
X    VT *vt;
X    char *text, *end;
X{
Xagain:
X    if (text >= end) {
X        vt->action = ansi_params;
X        return NULL;
X    }
X    if (isdigit(*text)) {
X        long a = *vt->nextarg;
X        if (a < 0) /* Still unused? */
X            a = 0;
X        do {
X            a = a*10 + (*text - '0');
X            CLIPMAX(a, 0x7fff); /* Avoid overflow */
X        } while (++text < end && isdigit(*text));
X        *vt->nextarg = a; /* Remember arg under construction */
X        if (text >= end)
X            goto again;
X    }
X    switch (*text) {
X
X    case ';': /* Arg no longer under construction */
X        ++text;
X        if (vt->nextarg < &vt->args[VTNARGS-1])
X            ++vt->nextarg; /* Else: overflow; who cares? */
X        *vt->nextarg = -1; /* Mark unused */
X        goto again;
X
X    case '?':
X        ++text;
X        if (vt->nextarg == vt->args && /* No arguments yet */
X            *vt->nextarg < 0 && vt->modarg == '\0') {
X            vt->modarg = '?';
X            goto again;
X        }
X        else { /* Illegal here */
X            D( printf("Wrong argcount in DEC private mode\n") );
X            FAIL();
X            return text;
X        }
X
X    default:
X        return ansi_execute(vt, text);
X    }
X}
X
X/* Called after complete ESC [ ? <number> h is parsed.
X   This is called DEC private mode set. Most stuff is not
X   implemented. The vt is guarantueed to contain the one
X   and only argument allowed here. */
X
XSTATIC void
Xvtprivset(vt)
X    VT *vt;
X{
X    switch (vt->args[0]) {
X    case 1:    /* Application cursor keys */
X        if (!vt->keypadmode) {
X            vt->keypadmode = 1;
X            vt->flagschanged = 1;
X        }
X        break;
X#if 0
X    case 3: /* 132 column mode */
X    case 4: /* Smooth (slow) scroll */
X#endif
X    case 5: /* Reverse video */
X        wfleep();
X        break;
X#if 0
X    case 6: /* Origin mode */
X    case 7: /* Wraparound mode */
X    case 8: /* Autorepeat keys */
X#endif
X    case 9: /* Send MIT mouse row & column on Button Press */
X        if (!vt->mitmouse) { /* If not already so */
X            vt->mitmouse = 1;
X            vt->flagschanged = 1;
X        }
X        break;
X#if 0
X    case 38: /* Enter Tektronix Mode */
X    case 40: /* Allow 80 <-> 132 mode */
X    case 41: /* Curses(5) fix */
X    case 44: /* Turn on margin bell */
X    case 45: /* Reverse wraparound mode */
X    case 46: /* Start logging */
X    case 47: /* Use alternate screen buffer */
X    case 1000: /* Send vt200 mouse row & column on Button Press */
X    case 1003: /* Send vt200 Hilite mouse row & column on Button Press */
X#endif
X    default:
X        D( printf("Unsupported DEC private mode set:") );
X        D( printf("esc [ ? %d h\n", vt->args[0]) );
X        wfleep();
X    }
X}
X
X/* Called after complete ESC [ ? <number> l is parsed.
X   This is called DEC private mode reset. The vt is guarantueed
X   to contain the one and only argument allowed here. */
X
XSTATIC void
Xvtprivreset(vt)
X    VT *vt;
X{
X    switch (vt->args[0]) {
X    case 1: /* Normal cursor keys */
X        if (vt->keypadmode) {
X            vt->keypadmode = 0;
X            vt->flagschanged = 1;
X        }
X        break;
X#if 0    /* These are not supprted: */
X    case 3: /* 80 column mode */
X    case 4: /* Jumpscroll */
X#endif
X    case 5: /* Normal video (i.e. not reverse) */
X        /* XXX Why this beep? */
X        wfleep();
X        break;
X#if 0
X    case 6: /* Normal cursor mode */
X    case 7: /* No wraparound */
X    case 8: /* No autorepeat */
X        break;
X#endif
X    case 9: /* Don't send mouse row & column on button press */
X    case 1000:    /* Same */
X    case 1003:    /* Same */
X        if (vt->mitmouse) { /* If not already so */
X            vt->mitmouse = 0;
X            vt->flagschanged = 1;
X        }
X        break;
X#if 0
X    case 40: /* Disallow 80 <-> 132 mode */
X    case 41: /* No curses(5) fix */
X    case 44: /* Turn off Margin bell */
X    case 45: /* No reverse wraparound */
X    case 46: /* Stop logging */
X    case 47: /* Use normal screen buffer (opposed to alternate buffer) */
X        break;
X#endif
X    default:
X        D( printf("Unsupported DEC private mode reset:") );
X        D( printf("esc [ ? %d l\n", vt->args[0]) );
X        wfleep();
X        break;
X    }
X}
X
X/* Action function called at last char of ANSI sequence.
X   (This is only called when the char is actually seen,
X   so there is no need for an 'end' parameter). */
X
XSTATIC char *
Xansi_execute(vt, text)
X    VT *vt;
X    char *text;
X{
X    int a1 = vt->args[0];
X    int a2 = (vt->nextarg > vt->args) ? vt->args[1] : -1;
X
X    if (vt->modarg == '?') {
X        /* These escape sequences have exactly one numeric parameter */
X        if (a1 < 0 || a2 > 0) {
X            wfleep();
X            return text+1;
X        }
X        switch (*text++) {
X        case 'h':    /* DEC Private mode Set */
X            vtprivset(vt);
X            break;
X        case 'l':    /* DEC Private mode Reset */
X            vtprivreset(vt);
X            break;
X        /* To do: add private mode memory to vt-descriptor? */
X        case 'r':    /* DEC Private mode Restore */
X        case 's':    /* DEC Private mode Save */
X        default:
X            /* Not supported or simply wrong */
X            wfleep();
X        }
X        return text;
X    }
X
X    CLIPMIN(a1, 1);
X    CLIPMIN(a2, 1);
X
X    switch (*text++) {
X    case '@': vtinschars(vt, a1);        break;
X    case 'A': vtarrow(vt, WC_UP, a1);    break;
X    case 'B': vtarrow(vt, WC_DOWN, a1);    break;
X    case 'C': vtarrow(vt, WC_RIGHT, a1);    break;
X    case 'D': vtarrow(vt, WC_LEFT, a1);    break;
X    case 'H':
X    case 'f': if (vt->nextarg > &vt->args[0])
X            vtsetcursor(vt, vt->topterm + a1 - 1, a2 - 1);
X          else vtsetcursor(vt, vt->topterm, 0);
X          break;
X    case 'J':
X        switch (vt->args[0]) {
X        case -1:
X        case 0:
X            vteosclear(vt, vt->topterm, 0);
X            break;
X        case 1:
X            /* clear above cursor */
X            break;
X        case 2:
X            vteosclear(vt, vt->cur_row, vt->cur_col);
X            break;
X        default:
X            FAIL();
X            break;
X        }
X        break;
X    case 'K':
X        switch (vt->args[0]) {
X        case -1:
X        case 0:
X            vteolclear(vt, vt->cur_row, vt->cur_col);
X            break;
X        case 1:
X            /* Clear left of cursor */
X            break;
X        case 2:
X            vteolclear(vt, vt->cur_row, 0);
X            break;
X        default:
X            FAIL();
X            break;
X        }
X        break;
X    case 'L': vtinslines(vt, a1);        break;
X    case 'M': vtdellines(vt, a1);        break;
X    case 'P': vtdelchars(vt, a1);        break;
X    case 'S': vtlinefeed(vt, a1);        break;
X    case 'T': vtrevlinefeed(vt, a1);    break;
X    case 'c': vtsendid(vt); break;
X    case 'g': /* Tab clear */        break;
X        /* 0: current col; 3: all */
X    case 'h': vtsetoptions(vt, TRUE);    break;
X    case 'l': vtsetoptions(vt, FALSE);    break;
X    case 'm': vtsetattrlist(vt);        break;
X    case 'n':
X        if (a1 == 6) vtsendpos(vt);
X        /* 5: echo 'ESC [ 0 n' */
X        break;
X    case 'r':
X        vtsetscroll(vt, vt->topterm+vt->args[0]-1, vt->topterm+a2);
X        break;
X    case 'x': /* Send terminal params */
X        break;
X    default:
X        FAIL();
X        break;
X    }
X
X    return text;
X}
X
X/* Set/reset numbered options given in args array */
X
XSTATIC void
Xvtsetoptions(vt, flag)
X    VT *vt;
X    bool flag; /* Set/reset */
X{
X    short *a;
X    for (a = vt->args; a <= vt->nextarg; ++a) {
X        switch (*a) {
X        case 4:
X            vtsetinsert(vt, flag);
X            break;
X        case -1:
X            /* Empty parameter, don't beep */
X            break;
X        default:
X            FAIL();
X            break;
X        }
X    }
X}
X
X/* Set/reset output mode attributes given in args array */
X
XSTATIC void
Xvtsetattrlist(vt)
X    VT *vt;
X{
X    short *a;
X    for (a = vt->args; a <= vt->nextarg; ++a) {
X        switch (*a) {
X        case -1:
X            if (a == vt->args)
X                vtresetattr(vt);
X            break;
X        case 0:
X            vtresetattr(vt);
X            break;
X        default:
X            vtsetattr(vt, *a);
X            break;
X        }
X    }
X}
END_OF_FILE
if test 11653 -ne `wc -c <'Packs/vt/vtansi.c'`; then
    echo shar: \"'Packs/vt/vtansi.c'\" unpacked with wrong size!
fi
# end of 'Packs/vt/vtansi.c'
fi
if test -f 'Ports/alfa/stdwin.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Ports/alfa/stdwin.c'\"
else
echo shar: Extracting \"'Ports/alfa/stdwin.c'\" \(9984 characters\)
sed "s/^X//" >'Ports/alfa/stdwin.c' <<'END_OF_FILE'
X/* TERMCAP STDWIN -- BASIC ROUTINES. */
X
X#include "alfa.h"
X
X#if defined(unix) || defined(AMOEBA)
X#define DO_SIGNAL
X#define DO_SYSTEM
X#endif
X
X#ifdef DO_SIGNAL
X#include <sys/types.h>
X#include <signal.h>
X#include "sigtype.h"
Xstatic SIGTYPE handler(); /* Forward */
X#endif
X
Xint lines, columns;
X
X/* Initialization call.
X   Should be called only once, before any others.
X   Will exit when the initialization fails. */
X
Xvoid
Xwinit()
X{
X    winitargs((int*)NULL, (char***)NULL);
X}
X
X/*ARGSUSED*/
Xvoid
Xwinitargs(pargc, pargv)
X    int *pargc;
X    char ***pargv;
X{
X    int flags;
X    int err;
X
X#ifdef DO_SIGNAL
X    (void) signal(SIGINT, handler);
X#ifdef NDEBUG
X    (void) signal(SIGQUIT, handler);
X#endif
X    (void) signal(SIGILL, handler);
X    (void) signal(SIGIOT, handler);
X    (void) signal(SIGEMT, handler);
X    (void) signal(SIGFPE, handler);
X    (void) signal(SIGBUS, handler);
X    (void) signal(SIGSEGV, handler);
X    (void) signal(SIGSYS, handler);
X    (void) signal(SIGTERM, handler);
X#endif /* DO_SIGNAL */
X
X    getttykeydefs(0);    /* File descriptor 0 */
X    err= trmstart(&lines, &columns, &flags);
X    if (err != 0) {
X        fprintf(stderr, "STDWIN: trmstart error %d\n", err);
X        exit(2);
X    }
X    gettckeydefs();
X    if (lines > MAXLINES)
X        lines= MAXLINES;
X    trmputdata(0, lines-1, 0, "");
X    initsyswin();
X    _winitmenus();
X}
X
X/* Termination call.
X   Should be called before the program exits
X   (else the terminal will be left in almost raw mode). */
X
Xvoid
Xwdone()
X{
X    if (lines > 0) {
X        /* Move cursor to last screen line. */
X        trmputdata(lines-1, lines-1, 0, "");
X        trmsync(lines-1, 0);
X    }
X    lines= 0;
X    trmend();
X}
X
X#ifdef DO_SIGNAL
X
X/* Signal handler.
X   Print a message and exit. */
X
Xstatic SIGTYPE
Xhandler(sig)
X    int sig;
X{
X    wdone();
X    signal(sig, SIG_DFL);
X    kill(0, sig);        /* Kill all others in our process group */
X    kill(getpid(), sig);    /* Commit suicide */
X    /* (On BSD, the signal is delivered to us only after we return.) */
X}
X
X#endif /* DO_SIGNAL */
X
X/* Essential data structures. */
X
XWINDOW winlist[MAXWINDOWS] /* = {FALSE, ...}, ... */;
X
XWINDOW *wasfront;    /* What the application thinks is active */
XWINDOW *front;        /* The window that is really active */
X    /* If these are not equal, an activate or deactivate event
X       will be generated by wevent before anything else. */
X
Xchar uptodate[MAXLINES] /* = FALSE, ... */;
X
X/* Open a window. */
X
XWINDOW *
Xwopen(title, drawproc)
X    char *title;
X    void (*drawproc)();
X{
X    int id;
X    WINDOW *win;
X
X    for (win= &winlist[0]; win < &winlist[MAXWINDOWS]; ++win) {
X        if (!win->open)
X            break;
X    }
X    id= win - &winlist[0];
X    if (id >= MAXWINDOWS)
X        return NULL;    /* Too many windows open */
X    win->open= TRUE;
X    _wreshuffle();
X    win->resized = FALSE;    /* Don't begin with a redraw event */
X    win->tag= 0;
X    win->drawproc= drawproc;
X    win->title= strdup(title);
X    win->attr= wattr;
X
X    win->offset= -win->top;
X    win->curh= win->curv= -1;
X    win->timer= 0;
X
X    initmenubar(&win->mbar);
X
X    front= win;
X    return win;
X}
X
X/* Divide the available lines over the available windows.
X   Line 0 is for window 0, the system window, and is different:
X   it has no title, and is always one line high, except when it's
X   the only window. */
X
Xvoid
X_wreshuffle()
X{
X    int nwins= 0;
X    int nlines= lines;
X    int top= 0;
X    WINDOW *win;
X
X    /* Count open windows. */
X    for (win= winlist; win < &winlist[MAXWINDOWS]; ++win) {
X        if (win->open)
X            ++nwins;
X    }
X    /* Assign each open window its share of the screen. */
X    for (win= winlist; win < &winlist[MAXWINDOWS]; ++win) {
X        if (win->open) {
X            int i= nlines/nwins;    /* This window's share */
X            int id= win - winlist;
X#ifdef LM_S_PROB
X            int oldtop= win->top, oldbot= win->bottom;
X            int dv, scrbot;
X#endif
X            /* Cause redraw event for old title position: */
X            if (win->top > 0)
X                uptodate[win->top-1]= FALSE;
X            if (id == 0) {    /* System window */
X                win->top= top;
X                if (nwins > 1)
X                    i=1;
X            }
X            else
X                win->top= top+1;
X            win->bottom= top + i;
X            nlines -= i;
X            --nwins;
X#ifndef LM_S_PROB
X            /* This is overkill;
X               we should try not cause a redraw of all lines! */
X            for (i= top; i < win->bottom; ++i) {
X                uptodate[i]= FALSE;
X            }
X#else
X            /* LM's probeersel */
X            dv= oldtop-win->top;
X            scrbot=win->bottom;
X            if (oldbot-dv < scrbot) scrbot=oldbot-dv;
X            scrollupdate(win->top, scrbot, dv);
X            trmscrollup(win->top, scrbot-1, dv);
X            for (i= top; i < win->bottom; ++i)
X                if (!(win->top <= i && i < scrbot ||
X                      win->top <= i+dv && i+dv < scrbot))
X                uptodate[i]= FALSE;
X#endif
X            top= win->bottom;
X            /* Cause redraw event for new title position: */
X            if (win->top > 0)
X                uptodate[win->top-1]= FALSE;
X            /* Cause resize event: */
X            win->resized= TRUE;
X            /* Scroll back if negative line numbers visible: */
X            if (win->top + win->offset < 0)
X                wshow(win, 0, 0,
X                    columns, win->bottom - win->top);
X#if 0 /* We don't really want to for showing the caret... */
X            /* Show caret: */
X            if (win->curv >= 0)
X                wshow(win, win->curh, win->curv,
X                    win->curh, win->curv);
X#endif
X        }
X    }
X}
X
X/* Close a window. */
X
Xvoid
Xwclose(win)
X    WINDOW *win;
X{
X    int id= win - winlist;
X
X    if (id < 0 || id >= MAXWINDOWS || !win->open)
X        return;
X    killmenubar(&win->mbar);
X    if (win == wasfront)
X        wasfront= NULL;
X    if (win == front)
X        front= NULL;
X    win->open= FALSE;
X    if (win->title != NULL) {
X        free(win->title);
X        win->title= NULL;
X    }
X    _wreshuffle();
X    /* Select another window. */
X    if (front == NULL) {
X        /* Search below the window we just closed. */
X        for (; win < &winlist[MAXWINDOWS]; ++win) {
X            if (win->open) {
X                front= win;
X                break; /* First hit is OK */
X            }
X        }
X        if (front == NULL) {
X            /* Try searching above it. */
X            for (win= winlist+1; win < &winlist[MAXWINDOWS];
X                                ++win) {
X                if (win->open)
X                    front= win;
X                /* NO break -- we need the last hit */
X            }
X        }
X        if (front == NULL) {
X            /* Exasperation time. */
X            front= &winlist[0]; /* The system window */
X        }
X        _wnewtitle(front); /* Make sure the title is redrawn */
X    }
X}
X
X/* Dummies for functions not supported by this version. */
X
X/*ARGSUSED*/
Xvoid
Xwsetdefwinpos(h, v)
X    int h, v;
X{
X}
X
X/*ARGSUSED*/
Xvoid
Xwsetdefwinsize(width, height)
X    int width, height;
X{
X}
X
X/*ARGSUSED*/
Xvoid
Xwsetmaxwinsize(width, height)
X    int width, height;
X{
X}
X
X/* Make a window the active window. */
X
Xvoid
Xwsetactive(win)
X    WINDOW *win;
X{
X    int id= win - winlist;
X
X    if (id < 0 || id >= MAXWINDOWS || !win->open)
X        return;
X    _wnewtitle(front);
X    front= win;
X    _wnewtitle(front);
X}
X
X/* Select next, previous window.
X   Note: these will never select the system window unless it is already
X   selected (which can only occur if there are no other windows open). */
X
Xvoid
X_wselnext()
X{
X    WINDOW *win;
X
X    for (win= front+1; win < &winlist[MAXWINDOWS]; ++win) {
X        if (win->open) {
X            wsetactive(win);
X            return;
X        }
X    }
X    for (win= winlist+1; win < front; ++win) {
X        if (win->open) {
X            wsetactive(win);
X            return;
X        }
X    }
X}
X
Xvoid
X_wselprev()
X{
X    WINDOW *win;
X
X    for (win= front-1; win > winlist; --win) {
X        if (win->open) {
X            wsetactive(win);
X            return;
X        }
X    }
X    for (win= &winlist[MAXWINDOWS-1]; win > front; --win) {
X        if (win->open) {
X            wsetactive(win);
X            return;
X        }
X    }
X}
X
X/* Force a redraw of the entire screen.
X   (This routine only sets 'invalid' bits for all lines;
X   the actual redraw is done later in wgetevent or wupdate.) */
X
Xvoid
X_wredraw()
X{
X    int i;
X
X    for (i= 0; i < lines; ++i)
X        uptodate[i]= FALSE;
X    _wreshuffle();
X    trmundefined();
X    trmputdata(0, lines-1, 0, "");
X}
X
X/* Temporarily restore cooked tty mode. */
X
X_wcooked()
X{
X    trmputdata(lines-1, lines-1, 0, "");
X    trmsync(lines-1, 0);
X    trmend();
X}
X
X/* Back to window mode.
X   If 'wait' flag is set, wait until a character is typed before
X   continuing. clearing the screen. */
X
X_wstdwin(wait)
X    bool wait;
X{
X    int flags;
X
X    if (wait) {
X        printf("\nCR to continue... ");
X        fflush(stdout);
X    }
X    (void) trmstart(&lines, &columns, &flags);
X    if (wait)
X        (void) trminput();
X    _wredraw();
X    wmessage((char *)NULL); /* Reset menu bar */
X}
X
X/* Suspend the process (BSD Unix only). */
X
Xvoid
X_wsuspend()
X{
X    _wcooked();
X    trmsuspend();
X    _wstdwin(FALSE);
X}
X
X/* Execute a shell command, if possible and necessary outside the window
X   manager.  If the 'wait' parameter is set, the window manager pauses
X   until a character is typed before continuing. */
X
Xint
Xwsystem(cmd, wait)
X    char *cmd;
X    bool wait;
X{
X#ifdef DO_SYSTEM
X    int status;
X    _wcooked();
X    status= system(cmd);
X    _wstdwin(wait);
X    return status;
X#else
X    return -1;
X#endif
X}
X
X/* Return active window. */
X
XWINDOW *
Xwgetactive()
X{
X    return front;
X}
X
X/* Change a window's title. */
X
Xvoid
Xwsettitle(win, title)
X    WINDOW *win;
X    char *title;
X{
X    if (win->title != NULL)
X        free(win->title);
X    win->title= strdup(title);
X    _wnewtitle(win);
X}
X
X/* Change the mouse cursor -- dummy */
X
X/*ARGSUSED*/
Xvoid
Xwsetwincursor(win, cursor)
X    WINDOW *win;
X    CURSOR *cursor;
X{
X}
X
X/* Fetch a mouse cursor -- always return NULL */
X
X/*ARGSUSED*/
XCURSOR *
Xwfetchcursor(name)
X    char *name;
X{
X    return NULL;
X}
X
X/* Set a window's extent (document size). Not implemented here. */
X
X/*ARGSUSED*/
Xvoid
Xwsetdocsize(win, width, height)
X    WINDOW *win;
X    int width, height;
X{
X}
X
X/*ARGSUSED*/
Xvoid
Xwgetdocsize(win, pwidth, pheight)
X    WINDOW *win;
X    int *pwidth, *pheight;
X{
X    *pwidth = *pheight = 0;
X}
X
X/* Get a window's origin with respect to document. */
X
Xvoid
Xwgetorigin(win, ph, pv)
X    WINDOW *win;
X    int *ph, *pv;
X{
X    *ph= 0;
X    *pv= win->top + win->offset;
X}
X
X/* Get a window's origin with respect to screen. */
X
Xvoid
Xwgetwinpos(win, ph, pv)
X    WINDOW *win;
X    int *ph, *pv;
X{
X    *ph= 0;
X    *pv= win->top;
X}
X
X/* Get a window's window size. */
X
Xvoid
Xwgetwinsize(win, pwidth, pheight)
X    WINDOW *win;
X    int *pwidth, *pheight;
X{
X    *pwidth= columns;
X    *pheight= win->bottom - win->top;
X}
X
X/* Get the screen size in pixels. */
X
Xvoid
Xwgetscrsize(ph, pv)
X    int *ph, *pv;
X{
X    *ph= columns;
X    *pv= lines;
X}
X
X/* Get the screen size in mm.
X   Of course we don't know it; we pretend that the average character
X   is 3 mm wide and 6 mm high, which is a reasonable approximation
X   of reality on my terminal (an HP2621). */
X
Xvoid
Xwgetscrmm(ph, pv)
X    int *ph, *pv;
X{
X    *ph= columns * 3;
X    *pv= lines * 6;
X}
X
Xvoid
Xwfleep()
X{
X    trmbell();
X}
END_OF_FILE
if test 9984 -ne `wc -c <'Ports/alfa/stdwin.c'`; then
    echo shar: \"'Ports/alfa/stdwin.c'\" unpacked with wrong size!
fi
# end of 'Ports/alfa/stdwin.c'
fi
if test -f 'Ports/mac/draw.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Ports/mac/draw.c'\"
else
echo shar: Extracting \"'Ports/mac/draw.c'\" \(10989 characters\)
sed "s/^X//" >'Ports/mac/draw.c' <<'END_OF_FILE'
X/* MAC STDWIN -- DOCUMENT DRAWING. */
X
X/* Contents of this file:
X
X   wchange, wscroll;
X   wbegindrawing, wenddrawing, _wupdate, wupdate;
X   text attribute manipulation (internal and external);
X   text measuring;
X   text drawing;
X   coordinate conversion tools;
X   ordinary drawing.
X
X   XXX Should be split, only things used between w{begin,end}drawing
X   belong here.
X
X   BEWARE OF COORDINATE SYSTEMS!
X
X   The window's origin is not always the same.
X   When the aplication isn't drawing (i.e., outside w{begin,end}drawing),
X   the origin is (0, 0); this is necessary because the control mgr
X   doesn't like it otherwise.
X   When the application is drawing, the origin is set to win->(orgh, orgv)
X   so the drawing primitives don't need to do their own coordinate
X   transformation.
X   Routines called while not drawing must do their own transformations.
X
X   XXX Routines that may be called any time are in trouble!
X   (There shouldn't be any.)
X*/
X
X#include "macwin.h"
X#ifdef MPW
X#include <Fonts.h>
X#endif
X
Xstatic WINDOW *drawing;
Xstatic TEXTATTR drawsaveattr;
Xstatic int baseline;
Xstatic int lineheight;
X
X/* Function prototypes */
X
XSTATIC void getwattr _ARGS((GrafPtr port, TEXTATTR *attr));
XSTATIC void setwattr _ARGS((TEXTATTR *attr));
XSTATIC void getfinfo _ARGS((void));
X
Xvoid
Xwchange(win, left, top, right, bottom)
X    WINDOW *win;
X    int left, top, right, bottom;
X{
X    Rect r;
X
X    SetPort(win->w);
X
X    if (drawing) dprintf("warning: wchange called while drawing");
X    makerect(win, &r, left, top, right, bottom);
X    InvalRect(&r);
X}
X
Xvoid
Xwscroll(win, left, top, right, bottom, dh, dv)
X    WINDOW *win;
X    int left, top, right, bottom;
X    int dh, dv;
X{
X    Rect r;
X
X    if (drawing) dprintf("warning: wchange called while drawing");
X    makerect(win, &r, left, top, right, bottom);
X    scrollby(win, &r, dh, dv);
X}
X
X/* Scroll a rectangle (given in window coordinates) by dh, dv.
X   Also used from scroll.c. */
X/* XXX need less visible name */
X
Xvoid
Xscrollby(win, pr, dh, dv)
X    WINDOW *win;
X    Rect *pr;
X    int dh, dv;
X{
X    RgnHandle rgn= NewRgn();
X
X    SetPort(win->w);
X
X    rmcaret(win);
X
X    if (!EmptyRgn(( (WindowPeek)win->w )->updateRgn)) {
X        RgnHandle ur= NewRgn();
X        int left, top;
X        Rect r;
X
X        /* Scroll the part of the update region that intersects
X           the scrolling area. */
X        CopyRgn(( (WindowPeek)win->w )->updateRgn, ur);
X        /* portBits.bounds is the screen in local coordinates! */
X        left= win->w->portBits.bounds.left;
X        top= win->w->portBits.bounds.top;
X        OffsetRgn(ur, left, top); /* Global to Local */
X        RectRgn(rgn, pr);
X        SectRgn(rgn, ur, ur);
X        if (!EmptyRgn(ur)) {
X            ValidRgn(ur);
X            OffsetRgn(ur, dh, dv);
X            SectRgn(rgn, ur, ur);
X            InvalRgn(ur);
X        }
X        DisposeRgn(ur);
X    }
X
X    ScrollRect(pr, dh, dv, rgn);
X    InvalRgn(rgn);
X
X    DisposeRgn(rgn);
X}
X
X
X/* Internal version of wupdate -- also used from event.c */
X
Xvoid
X_wupdate(win, pr)
X    WINDOW *win;
X    Rect *pr;
X{
X    RgnHandle rgn= NewRgn();
X
X    SetPort(win->w);
X
X    rmcaret(win);
X    BeginUpdate(win->w);
X    EraseRect(&win->w->portRect);
X    DrawGrowIcon(win->w);
X    DrawControls(win->w);
X    getwinrect(win, pr);
X    RectRgn(rgn, pr);
X    SectRgn(rgn, win->w->visRgn, rgn);
X    *pr= (*rgn)->rgnBBox;
X    OffsetRect(pr, win->orgh, win->orgv);
X    if (win->drawproc != NULL && !EmptyRect(pr)) {
X        wbegindrawing(win);
X        (*win->drawproc)(win, pr->left, pr->top, pr->right, pr->bottom);
X        wenddrawing(win);
X    }
X    EndUpdate(win->w);
X    DisposeRgn(rgn);
X}
X
X/* Process an update event -- call the window's draw procedure. */
X/* XXX This function shouldn't be in the stdwin spec (why was it ever?) */
X
Xvoid
Xwupdate(win)
X    WINDOW *win;
X{
X    if (win->drawproc != NULL) {
X        Rect r;
X        _wupdate(win, &r);
X    }
X}
X
Xvoid
Xwbegindrawing(win)
X    WINDOW *win;
X{
X    Rect r;
X
X    if (drawing != NULL) {
X        dprintf("warning: recursive call to wbegindrawing");
X        /* Fix it */
X        wenddrawing(drawing);
X    }
X    if (win == NULL) {
X        dprintf("warning: wbegindrawing(NULL) ignored");
X        return;
X    }
X    drawing= win;
X    SetPort(win->w);
X    SetOrigin(win->orgh, win->orgv);
X    rmcaret(win);
X    getwinrect(win, &r);
X    ClipRect(&r);
X    PenNormal();
X    wgettextattr(&drawsaveattr);
X    wsettextattr(&win->attr);
X}
X
Xvoid
Xwenddrawing(win)
X    WINDOW *win;
X{
X    Rect r;
X
X    if (drawing == NULL) {
X        dprintf("warning: wenddrawing ignored while not drawing");
X        return;
X    }
X    if (drawing != win) {
X        dprintf("warning: wenddrawing ignored for wrong window");
X        return;
X    }
X    SetOrigin(0, 0);
X    SetRect(&r, -32000, -32000, 32000, 32000);
X    ClipRect(&r);
X    wsettextattr(&drawsaveattr);
X    drawing= NULL;
X}
X
X/* Get the current text attributes of a GrafPort. */
X
Xstatic void
Xgetwattr(port, attr)
X    GrafPtr port;
X    TEXTATTR *attr;
X{
X    SetPort(port); /* XXX Is this necessary to validate txFont etc.? */
X
X    attr->font= port->txFont;
X    attr->style= port->txFace;
X    attr->size= port->txSize;
X}
X
X/* Start using the given text attributes in the current grafport. */
X
Xstatic void
Xsetwattr(attr)
X    TEXTATTR *attr;
X{
X    TextFont(attr->font);
X    TextFace(attr->style & ~TX_INVERSE);
X    TextSize(attr->size);
X}
X
X/* Get font info and baseline from current GrafPort */
X
Xstatic void
Xgetfinfo()
X{
X    FontInfo finfo;
X    GetFontInfo(&finfo);
X    baseline= finfo.ascent + finfo.leading;
X    lineheight= baseline + finfo.descent;
X}
X
X/* Initialize 'wattr'.  Uses the screen's grafport. */
X
Xint _w_font= applFont;
Xint _w_size= 9;
X
Xvoid
Xinitwattr()
X{
X    TEXTATTR saveattr;
X
X    SetPort(screen);
X
X    getwattr(screen, &saveattr);
X    TextFont(_w_font);
X    TextSize(_w_size);
X    getwattr(screen, &wattr);
X    getfinfo();
X    setwattr(&saveattr);
X}
X
X/* TEXT ATTRIBUTES. */
X
Xvoid
Xwgettextattr(attr)
X    TEXTATTR *attr;
X{
X    *attr= wattr;
X}
X
Xvoid
Xwsettextattr(attr)
X    TEXTATTR *attr;
X{
X    wattr= *attr;
X    if (drawing != NULL) {
X        setwattr(attr);
X        getfinfo();
X    }
X}
X
Xvoid
Xwgetwintextattr(win, attr)
X    WINDOW *win;
X    TEXTATTR *attr;
X{
X    *attr= win->attr;
X}
X
Xvoid
Xwsetwintextattr(win, attr)
X    WINDOW *win;
X    TEXTATTR *attr;
X{
X    win->attr= *attr;
X    if (drawing != NULL)
X        dprintf("warning: wsetwintextattr called while drawing");
X}
X
Xvoid
Xwsetfont(fontname)
X    char *fontname;
X{
X    if (fontname == NULL || *fontname == EOS)
X        wattr.font= _w_font;
X    else {
X        short fnum= 0;
X        GetFNum(PSTRING(fontname), &fnum);
X        if (fnum == 0)
X            dprintf("can't find font %s", fontname);
X        wattr.font= fnum;
X    }
X    if (drawing != NULL) {
X        TextFont(wattr.font);
X        getfinfo();
X    }
X
X}
X
Xvoid
Xwsetsize(size)
X    int size;
X{
X    wattr.size= size;
X    if (drawing != NULL) {
X        TextSize(size);
X        getfinfo();
X    }
X}
X
Xvoid
Xwsetstyle(face)
X    Style face;
X{
X    wattr.style= face;
X    if (drawing != NULL) {
X        TextFace(face & ~TX_INVERSE);
X        getfinfo();
X    }
X}
X
Xvoid
Xwsetplain()
X{
X    wsetstyle(0);
X}
X
Xvoid
Xwsetinverse()
X{
X    wattr.style |= TX_INVERSE;
X}
X
Xvoid
Xwsetbold()
X{
X    wsetstyle(bold);
X}
X
Xvoid
Xwsetitalic()
X{
X    wsetstyle(italic);
X}
X
Xvoid
Xwsetbolditalic()
X{
X    wsetstyle(bold|italic);
X}
X
Xvoid
Xwsetunderline()
X{
X    wsetstyle(underline);
X}
X
Xvoid
Xwsethilite()
X{
X    wsetstyle(TX_INVERSE);
X}
X
X/* TEXT MEASURING. */
X
Xint
Xwlineheight()
X{
X    if (drawing == NULL) {
X        TEXTATTR saveattr;
X        getwattr(screen, &saveattr);
X        setwattr(&wattr);
X        getfinfo();
X        setwattr(&saveattr);
X    }
X    return lineheight;
X}
X
Xint
Xwbaseline()
X{
X    if (drawing == NULL)
X        (void) wlineheight();
X    return baseline;
X}
X
Xint
Xwtextwidth(str, len)
X    char *str;
X    int len;
X{
X    TEXTATTR saveattr;
X    int width;
X
X    if (drawing == NULL) {
X        getwattr(screen, &saveattr);
X        setwattr(&wattr);
X    }
X    if (len < 0)
X        len= strlen(str);
X    width= TextWidth(str, 0, len);
X    if (drawing == NULL)
X        setwattr(&saveattr);
X    return width;
X}
X
Xint
Xwcharwidth(c)
X    int c;
X{
X    char cbuf[1];
X    cbuf[0]= c;
X    return wtextwidth(cbuf, 1);
X}
X
X/* TEXT DRAWING. */
X
Xvoid
Xwdrawtext(h, v, str, len)
X    int h, v;
X    char *str;
X    int len;
X{
X    Point pen;
X
X    if (len < 0)
X        len= strlen(str);
X    MoveTo(h, v + baseline);
X    DrawText(str, 0, len);
X    GetPen(&pen);
X    if (wattr.style & TX_INVERSE) {
X        Rect r;
X        SetRect(&r, h, v, pen.h, v + lineheight);
X        InvertRect(&r);
X    }
X}
X
Xvoid
Xwdrawchar(h, v, c)
X    int h, v;
X    int c;
X{
X    if ((wattr.style & TX_INVERSE) == 0) {
X        /* Attempt to optimize for appls. like dpv */
X        MoveTo(h, v + baseline);
X        DrawChar(c);
X    }
X    else {
X        char cbuf[1];
X        cbuf[0]= c;
X        wdrawtext(h, v, cbuf, 1);
X    }
X}
X
X/* COORDINATE CONVERSIONS ETC. */
X
X/* Create a rect in current window coordinates (as for getwinrect)
X   from a rectangle given in document coordinates.
X   This works both while drawing and while not drawing.
X   The resulting rectangle is clipped to the winrect. */
X
Xvoid
Xmakerect(win, pr, left, top, right, bottom)
X    WINDOW *win;
X    Rect *pr;
X    int left, top, right, bottom;
X{
X    Rect r;
X    SetRect(pr, left, top, right, bottom);
X    if (!drawing)
X        OffsetRect(pr, - win->orgh, - win->orgv);
X    getwinrect(win, &r);
X    (void) SectRect(&r, pr, pr);
X}
X
X/* Retrieve the 'winrect', i.e., the contents area exclusive
X   of the scroll bars and grow icon.
X   Coordinates are in window coordinates, i.e.,
X   the origin is (0, 0) outside w{begin,end}drawing,
X   but (win->orgh, win->orgv) between calls to these routines. */
X
Xvoid
Xgetwinrect(win, pr)
X    WINDOW *win;
X    Rect *pr;
X{
X    *pr= win->w->portRect;
X    pr->right -= BAR;
X    pr->bottom -= BAR;
X}
X
X/* ACTUAL DRAW ROUTINES. */
X
Xvoid
Xwdrawline(h1, v1, h2, v2)
X{
X    MoveTo(h1, v1);
X    Line(h2-h1, v2-v1);
X}
X
Xvoid
Xwxorline(h1, v1, h2, v2)
X{
X    MoveTo(h1, v1);
X    PenMode(patXor);
X    Line(h2-h1, v2-v1);
X    PenNormal();
X}
X
Xvoid
Xwdrawbox(left, top, right, bottom)
X    int left, top, right, bottom;
X{
X    Rect r;
X
X    SetRect(&r, left, top, right, bottom);
X    FrameRect(&r);
X}
X
Xvoid
Xwerase(left, top, right, bottom)
X    int left, top, right, bottom;
X{
X    Rect r;
X
X    SetRect(&r, left, top, right, bottom);
X    EraseRect(&r);
X}
X
Xvoid
Xwinvert(left, top, right, bottom)
X    int left, top, right, bottom;
X{
X    Rect r;
X
X    SetRect(&r, left, top, right, bottom);
X    InvertRect(&r);
X}
X
Xvoid
Xwpaint(left, top, right, bottom)
X    int left, top, right, bottom;
X{
X    Rect r;
X
X    SetRect(&r, left, top, right, bottom);
X    FillRect(&r, QD(black));
X}
X
Xvoid
Xwshade(left, top, right, bottom, perc)
X    int left, top, right, bottom;
X    int perc;
X{
X    Rect r;
X    unsigned char *p; /* really Pattern * or PatPtr */
X
X    perc= (perc + 12)/25;
X    CLIPMIN(perc, 0);
X
X    switch (perc) {
X    case 0:    p= &QD(white)[0];    break;
X    case 1: p= &QD(ltGray)[0];    break;
X    case 2: p= &QD(gray)[0];     break;
X    case 3: p= &QD(dkGray)[0];    break;
X    default: p= &QD(black)[0];    break;
X    }
X
X    SetRect(&r, left, top, right, bottom);
X
X    FillRect(&r, p);
X}
X
Xvoid
Xwdrawcircle(h, v, radius)
X    int h, v;
X    int radius;
X{
X    Rect r;
X
X    /* XXX Isn't there an off-by-one error here? */
X    SetRect(&r, h-radius, v-radius, h+radius, v+radius);
X    FrameOval(&r);
X}
X
X/* Draw counterclockwise elliptical arc.
X   h, v are center; hrad, vrad are half axes; ang1 and ang2 are start
X   and stop angles in degrees, with respect to 3 o'clock. */
X
Xvoid
Xwdrawelarc(h, v, hrad, vrad, ang1, ang2)
X{
X    Rect r;
X    /* XXX Does this work? No off-by-one errors? */
X    SetRect(&r, h-hrad, v-vrad, h+hrad, v+vrad);
X    FrameArc(&r, 90-ang1, ang1-ang2); /* ??? */
X}
X
X/* CLIPPING */
X
Xvoid
Xwcliprect(left, top, right, bottom)
X    int left, top, right, bottom;
X{
X    Rect r1, r2;
X    SetRect(&r1, left, top, right, bottom);
X    getwinrect(drawing, &r2);
X    SectRect(&r1, &r2, /*dst:*/ &r2);
X    ClipRect(&r2);
X
X}
X
Xvoid
Xwnoclip()
X{
X    Rect r;
X    getwinrect(drawing, &r);
X    ClipRect(&r);
X}
END_OF_FILE
if test 10989 -ne `wc -c <'Ports/mac/draw.c'`; then
    echo shar: \"'Ports/mac/draw.c'\" unpacked with wrong size!
fi
# end of 'Ports/mac/draw.c'
fi
if test -f 'Ports/x11/menu.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Ports/x11/menu.c'\"
else
echo shar: Extracting \"'Ports/x11/menu.c'\" \(11775 characters\)
sed "s/^X//" >'Ports/x11/menu.c' <<'END_OF_FILE'
X/* X11 STDWIN -- Menu handling */
X
X#include "x11.h"
X#include "llevent.h" /* For _w_dirty */
X
Xstatic bool local; /* When zero, menus are created global */
X
Xstatic int nmenus;
Xstatic MENU **menulist; /* Only global menus */
X
Xstatic MENU *sysmenu; /* System menu, included in each window's mbar */
X
Xstatic
Xmbardirty(win)
X    WINDOW *win;
X{
X    _w_dirty= win->mbar.dirty= TRUE;
X}
X
Xvoid
Xwmenusetdeflocal(flag)
X    bool flag;
X{
X    local= flag;
X}
X
Xvoid
Xwmenuattach(win, mp)
X    WINDOW *win;
X    MENU *mp;
X{
X    int i;
X
X    for (i= 0; i < win->nmenus; ++i) {
X        if (win->menulist[i] == mp)
X            return; /* Already attached */
X    }
X    L_APPEND(win->nmenus, win->menulist, MENU *, mp);
X    mbardirty(win);
X}
X
Xvoid
Xwmenudetach(win, mp)
X    WINDOW *win;
X    MENU *mp;
X{
X    int i;
X
X    for (i= 0; i < win->nmenus; ++i) {
X        if (win->menulist[i] == mp) {
X            L_REMOVE(win->nmenus, win->menulist, MENU *, i);
X            mbardirty(win);
X            break;
X        }
X    }
X}
X
X_waddmenus(win)
X    WINDOW *win;
X{
X    int i;
X
X    /* Create system menu if first time here */
X    if (sysmenu == NULL) {
X        bool savelocal= local;
X        wmenusetdeflocal(TRUE);
X        sysmenu= wmenucreate(0, "X");
X        if (sysmenu != NULL)
X            wmenuadditem(sysmenu, "Close", -1);
X        wmenusetdeflocal(savelocal);
X    }
X
X    /* Initialize the nonzero variables used by the menu module */
X    win->curmenu= win->curitem= -1;
X
X    /* Add system menu and all global menus to the menu list */
X    if (sysmenu != NULL) {
X        L_APPEND(win->nmenus, win->menulist, MENU *, sysmenu);
X    }
X    for (i= 0; i < nmenus; ++i) {
X        L_APPEND(win->nmenus, win->menulist, MENU *, menulist[i]);
X    }
X    if (nmenus > 0)
X        mbardirty(win);
X}
X
X_w_delmenus(win)
X    WINDOW *win;
X{
X    /* Delete the menu list before closing a window */
X    L_DEALLOC(win->nmenus, win->menulist);
X}
X
XMENU *
Xwmenucreate(id, title)
X    int id;
X    char *title;
X{
X    MENU *mp= ALLOC(MENU);
X
X    if (mp == NULL)
X        return NULL;
X    mp->id= id;
X    mp->title= strdup(title);
X    mp->nitems= 0;
X    mp->itemlist= NULL;
X    if (!local) {
X        L_APPEND(nmenus, menulist, MENU *, mp);
X        _waddtoall(mp);
X    }
X    return mp;
X}
X
Xvoid
Xwmenudelete(mp)
X    MENU *mp;
X{
X    int i;
X
X    for (i= 0; i < nmenus; ++i) {
X        if (menulist[i] == mp) {
X            L_REMOVE(nmenus, menulist, MENU *, i);
X            break;
X        }
X    }
X    _wdelfromall(mp);
X
X    for (i= 0; i < mp->nitems; ++i)
X        FREE(mp->itemlist[i].text);
X    FREE(mp->itemlist);
X    FREE(mp);
X}
X
Xint
Xwmenuadditem(mp, text, shortcut)
X    MENU *mp;
X    char *text;
X    int shortcut;
X{
X    struct item it;
X
X    it.text= strdup(text);
X    if (shortcut < 0)
X        it.sctext= NULL;
X    else {
X        char buf[50];
X        sprintf(buf, "M-%c", shortcut);
X        it.sctext= strdup(buf);
X    }
X    it.shortcut= shortcut;
X    it.enabled=  it.text != NULL && it.text[0] != EOS;
X    it.checked= FALSE;
X    L_APPEND(mp->nitems, mp->itemlist, struct item, it);
X    return mp->nitems - 1;
X}
X
Xvoid
Xwmenusetitem(mp, i, text)
X    MENU *mp;
X    int i;
X    char *text;
X{
X    if (i < 0 || i >= mp->nitems)
X        return;
X    FREE(mp->itemlist[i].text);
X    mp->itemlist[i].text= strdup(text);
X}
X
Xvoid
Xwmenuenable(mp, i, flag)
X    MENU *mp;
X    int i;
X    bool flag;
X{
X    if (i < 0 || i >= mp->nitems)
X        return;
X    mp->itemlist[i].enabled= flag;
X}
X
Xvoid
Xwmenucheck(mp, i, flag)
X    MENU *mp;
X    int i;
X    bool flag;
X{
X    if (i < 0 || i >= mp->nitems)
X        return;
X    mp->itemlist[i].checked= flag;
X}
X
X/* --- system-dependent code starts here --- */
X
X/*
XXXX Stuff recomputed more than I like:
X    - length of menu titles and menu item texts
X    - menu item text widths
X*/
X
X#define NOITEM (-1)
X#define NOMENU (-1)
X
X/* Precomputed values (assume _wdrawmbar is always called first) */
Xstatic int baseline;
Xstatic int lineheight;
Xstatic int halftitledist;
X#define titledist (2*halftitledist)
Xstatic int shortcutdist;
X
Xstatic
X_wmenusetup()
X{
X    shortcutdist= XTextWidth(_wmf, "    ", 4);
X    halftitledist= XTextWidth(_wmf, "0", 1);
X    baseline= _wmf->ascent;
X    lineheight= _wmf->ascent + _wmf->descent;
X}
X
X/* Draw the menu bar.
X   Called via the normal exposure event mechanism. */
X
X_wdrawmbar(win)
X    WINDOW *win;
X{
X    int i;
X    int x;
X    int y;
X
X    _wmenusetup();
X    x= titledist;
X    y= baseline - 1 + (win->mbar.height - lineheight) / 2;
X
X    XClearWindow(_wd, win->mbar.wid);
X    for (i= 0; i < win->nmenus; ++i) {
X        char *title= win->menulist[i]->title;
X        int len= strlen(title);
X        XDrawString(_wd, win->mbar.wid, win->gc, x, y, title, len);
X        x += XTextWidth(_wmf, title, len) + titledist;
X    }
X}
X
Xstatic
Xinverttitle(win, it)
X    WINDOW *win;
X    int it;
X{
X    int x= leftedge(win, it);
X    MENU *mp= win->menulist[it];
X    char *title= mp->title;
X    int len= strlen(title);
X    int width= XTextWidth(_wmf, title, len);
X
X    _winvert(win->mbar.wid, win->gc,
X        x-halftitledist, 0, width+titledist, win->mbar.height);
X}
X
Xstatic int
Xleftedge(win, it)
X    WINDOW *win;
X    int it;
X{
X    int i;
X    int x= titledist;
X
X    for (i= 0; i < it; ++i) {
X        char *title= win->menulist[i]->title;
X        int len= strlen(title);
X        int width= XTextWidth(_wmf, title, len);
X        x += width + titledist;
X    }
X
X    return x;
X}
X
X/* Draw the current menu */
X
Xstatic
Xdrawmenu(win)
X    WINDOW *win;
X{
X    int i;
X    int x= halftitledist;
X    int y= baseline;
X    MENU *mp= win->menulist[win->curmenu];
X
X    for (i= 0; i < mp->nitems; ++i) {
X        char *text= mp->itemlist[i].text;
X        int len= strlen(text);
X        char *marker= NULL;
X        if (!mp->itemlist[i].enabled) {
X            if (len > 0)
X                marker= "-";
X        }
X        else if (mp->itemlist[i].checked)
X            marker= "*";
X        if (marker != NULL) {
X            int width= XTextWidth(_wmf, marker, 1);
X            XDrawString(_wd, win->mwin.wid, win->gc,
X                (x-width)/2, y, marker, 1);
X        }
X        XDrawString(_wd, win->mwin.wid, win->gc, x, y, text, len);
X        text= mp->itemlist[i].sctext;
X        if (text != NULL) {
X            int width;
X            len= strlen(text);
X            width= XTextWidth(_wmf, text, len);
X            XDrawString(_wd, win->mwin.wid, win->gc,
X                win->mwin.width - width - halftitledist, y,
X                text, len);
X        }
X        y += lineheight;
X    }
X}
X
X/* Create the window for the menu.
X   It is a direct child of the outer window, but aligned with the
X   top of the inner window */
X
Xstatic
Xmakemenu(win)
X    WINDOW *win;
X{
X    int i;
X    int maxwidth= 0;
X    MENU *mp= win->menulist[win->curmenu];
X    Window child_dummy;
X
X    /* Compute the maximum item width.
X       Item width is the sum of:
X       - 1/2 title width (left margin, also used for tick marks)
X       - text width of item text
X       - if there is a shortcut:
X           - shortcutdist (some space between text and shortcut)
X           - text width of shortcut text
X       - 1/2 title width (right margin)
X    */
X
X    for (i= 0; i < mp->nitems; ++i) {
X        char *text= mp->itemlist[i].text;
X        int len= strlen(text);
X        int width= XTextWidth(_wmf, text, len);
X        text= mp->itemlist[i].sctext;
X        if (text != NULL) {
X            len= strlen(text);
X            width += XTextWidth(_wmf, text, len) + shortcutdist;
X        }
X        if (width > maxwidth)
X            maxwidth= width;
X    }
X
X    win->mwin.width= maxwidth + titledist;
X    win->mwin.height= mp->nitems * lineheight + 1;
X    CLIPMAX(win->mwin.width, WidthOfScreen(_ws));
X    CLIPMAX(win->mwin.height, HeightOfScreen(_ws));
X
X    if (!XTranslateCoordinates(_wd, win->wo.wid,
X        RootWindowOfScreen(_ws),
X        leftedge(win, win->curmenu) -halftitledist + win->mbar.x,
X        win->wi.y,
X        &win->mwin.x,
X        &win->mwin.y,
X        &child_dummy)) {
X
X        _wwarning("makemenu: XTranslateCoordinates failed");
X        win->mwin.x = win->mwin.y = 0;
X    }
X
X    CLIPMAX(win->mwin.x, WidthOfScreen(_ws) - win->mwin.width);
X    CLIPMAX(win->mwin.y, HeightOfScreen(_ws) - win->mwin.height);
X    CLIPMIN(win->mwin.x, 0);
X    CLIPMIN(win->mwin.y, 0);
X
X    win->mwin.dirty= TRUE;
X    win->mwin.border= IBORDER;
X
X    (void) _wcreate1(&win->mwin, RootWindowOfScreen(_ws), XC_arrow, FALSE,
X        win->fgo, win->bgo, 1);
X    _wsaveunder(&win->mwin, True);
X    XMapWindow(_wd, win->mwin.wid);
X    i = XGrabPointer(_wd,        /* display */
X        win->mwin.wid,        /* grab_window */
X        False,            /* owner_events */
X        ButtonMotionMask | ButtonReleaseMask,
X                    /* event_masks */
X        GrabModeAsync,        /* pointer_mode */
X        GrabModeAsync,        /* keyboard_mode */
X        None,            /* confine_to */
X        None,            /* cursor */
X        _w_lasttime        /* timestamp */
X        );
X    if (i != GrabSuccess) {
X        _wwarning("makemenu: XGrabPointer failed (err %d)", i);
X        /* Didn't get the grab -- forget about it */
X    }
X}
X
X/* Handle mouse state change in menu bar */
X
X_whitmbar(bsp, ep)
X    struct button_state *bsp;
X    EVENT *ep;
X{
X    WINDOW *win= bsp->win;
X
X    if (win->curmenu >= 0) {
X        /* We already created a menu.
X           This is probably an event that was queued before
X           the menu window was created. */
X        _wdebug(1, "_whitmbar: mouse in mwin");
X    }
X
X    if (!bsp->down)
X        hidemenu(win);
X    else if (bsp->y >= 0 && bsp->y <= win->mbar.height &&
X            bsp->x >= 0 && bsp->x <= win->mbar.width)
X        showmenu(win, whichmenu(win, bsp->x));
X}
X
X/* Handle mouse state change in menu.
X   (This is called with a fake button state from _whitmbar,
X   since the menu bar has grabbed the pointer) */
X
X/*static*/ /* Now called from event.c */
X_whitmwin(bsp, ep)
X    struct button_state *bsp;
X    EVENT *ep;
X{
X    WINDOW *win= bsp->win;
X    MENU *mp= win->menulist[win->curmenu];
X    int it;
X
X    if (bsp->x >= 0 && bsp->x <= win->mwin.width)
X        it= whichitem(mp, bsp->y);
X    else
X        it= NOITEM;
X    _wdebug(5, "_whitmwin: hit item %d", it);
X    hiliteitem(win, it);
X
X    if (!bsp->down) {
X        hidemenu(win);
X        XFlush(_wd); /* Show it right now */
X        if (it >= 0) {
X            if (mp->id == 0) {
X                ep->type= WE_COMMAND;
X                ep->u.command= WC_CLOSE;
X                ep->window= win;
X            }
X            else {
X                ep->type= WE_MENU;
X                ep->u.m.id= mp->id;
X                ep->u.m.item= it;
X                ep->window= win;
X            }
X        }
X    }
X}
X
X/* Show and hide menus */
X
Xstatic
Xshowmenu(win, newmenu)
X    WINDOW *win;
X    int newmenu;
X{
X    if (newmenu != win->curmenu) {
X        hidemenu(win);
X        if (newmenu >= 0) {
X            win->curmenu= newmenu;
X            win->curitem= NOITEM;
X            inverttitle(win, win->curmenu);
X            makemenu(win);
X            drawmenu(win);
X        }
X    }
X}
X
Xstatic
Xhidemenu(win)
X    WINDOW *win;
X{
X    if (win->curmenu >= 0) {
X        hiliteitem(win, NOITEM);
X        XDestroyWindow(_wd, win->mwin.wid);
X        win->mwin.wid= 0;
X        inverttitle(win, win->curmenu);
X        win->curmenu= NOMENU;
X    }
X}
X
X/* Compute which menu was hit */
X
Xstatic int
Xwhichmenu(win, xhit)
X    WINDOW *win;
X    int xhit;
X{
X    int i;
X    int x= halftitledist;
X
X    if (xhit < x)
X        return NOMENU;
X
X    for (i= 0; i < win->nmenus; ++i) {
X        char *title= win->menulist[i]->title;
X        int len= strlen(title);
X        x += XTextWidth(_wmf, title, len) + titledist;
X        if (xhit < x)
X            return i;
X    }
X
X    return NOMENU;
X}
X
X/* (Un)hilite the given menu item */
X
Xstatic
Xhiliteitem(win, it)
X    WINDOW *win;
X    int it;
X{
X    if (it != win->curitem) {
X        if (win->curitem >= 0)
X            invertitem(win, win->curitem);
X        if (it >= 0)
X            invertitem(win, it);
X        win->curitem= it;
X    }
X}
X
Xstatic
Xinvertitem(win, it)
X    WINDOW *win;
X    int it;
X{
X    int top, size;
X
X    size= lineheight;
X    top= it*size;
X    _winvert(win->mwin.wid, win->gc, 0, top, win->mwin.width, size);
X}
X
X/* Compute which item was hit */
X
Xstatic int
Xwhichitem(mp, yhit)
X    MENU *mp;
X    int yhit;
X{
X    int it= yhit < 0 ? NOITEM : yhit / lineheight;
X
X    _wdebug(4, "whichitem: yhit=%d, it=%d", yhit, it);
X    if (it >= 0 && it < mp->nitems && mp->itemlist[it].enabled)
X        return it;
X    else
X        return NOITEM;
X}
X
X/* Generate a menu selection event from a meta-key press.
X   *ep has the window already filled in. */
X
Xbool
X_w_menukey(c, ep)
X    int c;
X    EVENT *ep;
X{
X    WINDOW *win= ep->window;
X    int i;
X    int altc;
X    bool althit= FALSE;
X
X    c &= 0xff;
X
X    if (islower(c))
X        altc= toupper(c);
X    else if (isupper(c))
X        altc= tolower(c);
X    else
X        altc= 0;
X
X    for (i= 0; i < win->nmenus; ++i) {
X        MENU *mp= win->menulist[i];
X        int j;
X        for (j= 0; j < mp->nitems; ++j) {
X            if (mp->itemlist[j].shortcut == c) {
X                ep->type= WE_MENU;
X                ep->u.m.id= mp->id;
X                ep->u.m.item= j;
X                return TRUE;
X            }
X            else if (altc != 0 && !althit &&
X                mp->itemlist[j].shortcut == altc) {
X                ep->u.m.id= mp->id;
X                ep->u.m.item= j;
X                althit= TRUE;
X            }
X        }
X    }
X    if (althit)
X        ep->type= WE_MENU;
X    return althit;
X}
X
X/* Delete all menus -- called by wdone().
X   (In fact local menus aren't deleted since they aren't in the menu list). */
X
X_wkillmenus()
X{
X    while (nmenus > 0)
X        wmenudelete(menulist[nmenus-1]);
X    if (sysmenu != NULL) {
X        wmenudelete(sysmenu);
X        sysmenu= NULL;
X    }
X}
END_OF_FILE
if test 11775 -ne `wc -c <'Ports/x11/menu.c'`; then
    echo shar: \"'Ports/x11/menu.c'\" unpacked with wrong size!
fi
# end of 'Ports/x11/menu.c'
fi
if test -f 'Ports/x11/timer.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Ports/x11/timer.c'\"
else
echo shar: Extracting \"'Ports/x11/timer.c'\" \(5523 characters\)
sed "s/^X//" >'Ports/x11/timer.c' <<'END_OF_FILE'
X/* X11 STDWIN -- Alarm timers (BSD-specific) */
X
X#ifdef AMOEBA
X#include "amtimer.c"
X#else /* !AMOEBA */
X
X#include "x11.h"
X
X#include <errno.h>
X
X/* Alarm timer values must be stored as absolute times,
X   but since they are in tenths of a second and stored in a long,
X   there isn't enough space to store the true absolute time.
X   Therefore, they are stored relative to the second when the
X   first call to wsettimer was made, which is saved in torigin */
X
Xstatic long torigin;        /* Seconds */
Xstatic long nexttimer;        /* Deciseconds */
X
X/* Compute a new value for nexttimer.
X   Return the relevant window as a convenience */
X
Xstatic WINDOW *
Xsetnexttimer()
X{
X    WINDOW *win= _wnexttimer();
X
X    if (win == NULL)
X        nexttimer= 0;
X    else
X        nexttimer= win->timer;
X    _wdebug(3, "setnexttimer: nexttimer at %d for %x", nexttimer, win);
X    return win;
X}
X
X/* Set the alarm timer for a given window */
X
Xvoid wsettimer(win, deciseconds)
X    WINDOW *win;
X    int deciseconds;
X{
X    _wdebug(3, "wsettimer: deciseconds=%d", deciseconds);
X    win->timer= 0;
X    if (deciseconds > 0) {
X        struct timeval tv;
X        struct timezone tz;
X
X        if (gettimeofday(&tv, &tz) < 0) {
X            _wwarning("wsettimer: can't get time of day");
X        }
X        else {
X            if (torigin == 0) {
X                torigin= tv.tv_sec;
X                _wdebug(3, "wsettimer: torigin %d", torigin);
X            }
X            win->timer= deciseconds + 10 * (tv.tv_sec - torigin) +
X                tv.tv_usec/100000;
X            _wdebug(4, "wsettimer(%d): timer set to %d",
X                deciseconds, win->timer);
X        }
X    }
X    (void) setnexttimer();
X}
X
X/* Return a pointer suitable as timeout parameter for BSD select(2).
X   If no alarms are currently set, return a NULL pointer */
X
Xstatic struct timeval *
Xtimeout()
X{
X    if (nexttimer == 0) {
X        _wdebug(4, "timeout: no timers set");
X        return NULL;
X    }
X    else {
X        static struct timeval tv;
X        struct timezone tz;
X
X        if (gettimeofday(&tv, &tz) < 0) {
X            _wwarning("timeout: can't get time of day");
X            return NULL;
X        }
X        else {
X            long tout;
X            tout= nexttimer
X                - (tv.tv_sec - torigin) * 10
X                - tv.tv_usec / 100000;
X            if (tout <= 0)
X                tv.tv_sec= tv.tv_usec= 0;
X            else {
X                tv.tv_sec= tout / 10;
X                tv.tv_usec= (tout % 10) * 100000;
X            }
X            _wdebug(4, "timeout: delay %d sec %d usec",
X                tv.tv_sec, tv.tv_usec);
X            return &tv;
X        }
X    }
X}
X
X/* Check if an alarm has gone off, and if so, generate an appropriate event.
X   This can be called at any time, but for efficiency reasons it should
X   only be called when an alarm has actually gone of (i.e., select has
X   timed out).  If an alarm has gone off, it will always be found by
X   this function */
X
Xstatic bool
Xdotimer(ep)
X    EVENT *ep;
X{
X    WINDOW *win= setnexttimer();
X    struct timeval *tp;
X
X    if (win == NULL) {
X        _wdebug(1, "dotimer: no event found (spurious call)");
X        return FALSE;
X    }
X    tp= timeout();
X    if (tp == NULL) {
X        _wdebug(1, "dotimer: unexpected NULL timeout()");
X        return FALSE;
X    }
X    if (tp->tv_sec == 0 && tp->tv_usec == 0) {
X        _wdebug(3, "dotimer: reporting timer event");
X        ep->type= WE_TIMER;
X        ep->window= win;
X        win->timer= 0;
X        (void) setnexttimer();
X        return TRUE;
X    }
X    else {
X        _wdebug(1, "dotimer: it is not yet time");
X        return FALSE;
X    }
X}
X
X/* Check for timer events.
X   Call this after XPending returns 0, just before calling XNextEvent */
X
Xbool
X_w_checktimer(ep, mayblock)
X    EVENT *ep;
X    bool mayblock;
X{
X    for (;;) {
X        struct timeval *tp= timeout();
X        /* This is naive.  BSD 4.3 really uses an array of longs
X           as arguments to select.  Hope there aren't >32 fds, or
X           the socket and pipe are among the first 32 files opened */
X        unsigned long rd, wd, xd;
X        int fd, nfd;
X        int nfound;
X        if (tp != NULL)
X            _wdebug(4, "_wchecktimer: sec=%d, usec=%d",
X                tp->tv_sec, tp->tv_usec);
X        if (!mayblock) {
X            if (tp != NULL)
X                _wdebug(4, "_wchecktimer: !mayblock");
X            return tp != NULL &&
X                tp->tv_sec == 0 && tp->tv_usec == 0 &&
X                dotimer(ep);
X        }
X        fd= _wd->fd;
X        rd= 1 << fd;
X        nfd= fd+1;
X#ifdef PIPEHACK
X        if (_wpipe[0] >= 0) {
X            rd |= (1 << _wpipe[0]);
X            if (_wpipe[0]+1 > nfd)
X                nfd= _wpipe[0]+1;
X        }
X#endif
X        wd= xd= 0;
X        if (tp == NULL)
X            _wdebug(4, "wchecktimer: select w/o timeout");
X        else
X            _wdebug(4,
X                "_wchecktimer: select call, sec=%d, usec=%d",
X                tp->tv_sec, tp->tv_usec);
X#ifdef AMOEBA
X        /* Amoeba is far superior to unix:
X           we don't need something as silly as select... */
X        nfound= EIO;
X#else
X        nfound= select(nfd, &rd, &wd, &xd, tp);
X#endif
X        _wdebug(4, "_wchecktimer: select returned %d", nfound);
X        /* Note: if select returns negative, we also break
X           out of the loop -- better drop a timer event than
X           loop forever on a select error.
X           The only exception is EINTR, which may have been caused
X           by an application's signal handler */
X        if (nfound < 0) {
X            if (errno == EINTR) {
X                _wdebug(4, "_wchecktimer: select interrupted");
X                continue;
X            }
X            else {
X#ifdef AMOEBA
X                if (errno != EIO)
X#endif
X                _wwarning(
X                    "_wchecktimer: select failed, errno=%d",
X                    errno);
X            }
X        }
X        if (nfound != 0)
X            break;
X        if (dotimer(ep))
X            return TRUE;
X    }
X    _wdebug(4, "_wchecktimer: returning FALSE");
X    return FALSE;
X}
X
X/* P.S.: It is not necessary to recompute nextalarm when windows are
X   deleted.  This can at most cause a spurious time-out, after which
X   dotimeout() is called again which recomputes nextalarm as a side
X   effect (twice, even).  Applications incur a slight overhead if they
X   delete a window with a timer set and no other windows have timers
X   set; in this case a larger part of the timeout code is called until
X   the alarm goes off (which is then ignored!). */
X
X#endif /* !AMOEBA */
END_OF_FILE
if test 5523 -ne `wc -c <'Ports/x11/timer.c'`; then
    echo shar: \"'Ports/x11/timer.c'\" unpacked with wrong size!
fi
# end of 'Ports/x11/timer.c'
fi
echo shar: End of archive 9 \(of 19\).
cp /dev/null ark9isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 19 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0