Return to mac.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove

Annotation of 43BSDReno/contrib/jove/mac.c, revision 1.1

1.1     ! root        1: /***************************************************************************
        !             2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
        !             3:  * is provided to you without charge, and with no warranty.  You may give  *
        !             4:  * away copies of JOVE, including sources, provided that this notice is    *
        !             5:  * included in all the files.                                              *
        !             6:  ***************************************************************************/
        !             7: 
        !             8: 
        !             9: /* (C) 1986, 1987, 1988 Ken Mitchum. This code is intended only for use with Jove. */
        !            10: 
        !            11: #include "tune.h"
        !            12: #ifdef MAC
        !            13: #define _mac
        !            14: #include <MacTypes.h>
        !            15: #include "jove.h"
        !            16: #include <QuickDraw.h>
        !            17: #include <WindowMgr.h>
        !            18: #include <FontMgr.h>
        !            19: #include <ListMgr.h>
        !            20: #include <EventMgr.h>
        !            21: #include <ControlMgr.h>
        !            22: #include <DialogMgr.h>
        !            23: #include <ResourceMgr.h>
        !            24: #include <ToolboxUtil.h>
        !            25: #include <HFS.h>
        !            26: #include <StdFilePkg.h>
        !            27: #include <MenuMgr.h>
        !            28: #include <pascal.h>
        !            29: #include <errno.h>
        !            30: #include <SegmentLdr.h>
        !            31: #include "mac.h"
        !            32: #include "termcap.h"
        !            33: 
        !            34: /***************************************************/
        !            35: 
        !            36: /* these normally reside in "tune.c" which we don't use */
        !            37: 
        !            38: char *CmdDb;   /* see InitMac() */
        !            39: char *p_tempfile = ".jrecXXX";
        !            40: char *d_tempfile = ".joveXXX";
        !            41: char *Joverc = ".joverc";
        !            42: 
        !            43: 
        !            44: void putcurs(),curset(),putp(),dellines(),inslines();
        !            45: 
        !            46: static Rect LimitRect; /* bounds we can't move past */
        !            47: 
        !            48: struct wind_config {
        !            49:        int w_width;    /* pixel width of the Mac window */
        !            50:        int     w_height;
        !            51:        int     w_rows; /* rows of characters which fit the window */
        !            52:        int     w_cols;
        !            53: } wc_std, wc_user, *wc;
        !            54: 
        !            55: static WindowPtr theScreen;
        !            56: 
        !            57: int
        !            58:        errno,
        !            59:        EventCmd,
        !            60:        Keyonly,
        !            61:        Macmode,
        !            62:        Bufchange,
        !            63:        Modechange,
        !            64:        Windchange;
        !            65: 
        !            66: /* Initialization Routines. */
        !            67: 
        !            68: void InitBinds()
        !            69: {
        !            70:        struct cmd *c;
        !            71:        data_obj **p;
        !            72:        int i;
        !            73: 
        !            74:        p = MainKeys;
        !            75:        for(i= 0; i < NCHARS; i++) {
        !            76:                c = (struct cmd *) *p;
        !            77:                c->c_map = F_MAINMAP;
        !            78:                c->c_key = i;
        !            79:                p++;
        !            80:        }
        !            81: 
        !            82:        p = EscKeys;
        !            83:        for(i= 0; i < NCHARS; i++) {
        !            84:                c = (struct cmd *) *p;
        !            85:                c->c_map = F_PREF1MAP;
        !            86:                c->c_key = i;
        !            87:                p++;
        !            88:        }
        !            89:        p = CtlxKeys;
        !            90:        for(i= 0; i < NCHARS; i++) {
        !            91:                c = (struct cmd *) *p;
        !            92:                c->c_map = F_PREF2MAP;
        !            93:                c->c_key = i;
        !            94:                p++;
        !            95:        }
        !            96: 
        !            97: }
        !            98: 
        !            99: static WindowPtr window;
        !           100: static Rect r;
        !           101: static CursHandle cross;
        !           102: 
        !           103: void InitEvents()
        !           104: {
        !           105:        void InitSysMenu();
        !           106: 
        !           107:        window = theScreen;
        !           108:        InitSysMenu();
        !           109:        SetRect(&r,window->portRect.left,
        !           110:        window->portRect.top,
        !           111:        window->portRect.right - SCROLLWIDTH,
        !           112:        window->portRect.bottom - SCROLLWIDTH);
        !           113:        cross = GetCursor(crossCursor);
        !           114: }
        !           115: 
        !           116: void MacInit()
        !           117: {
        !           118:        char *gethome();
        !           119:        void tn_init();
        !           120: 
        !           121:        tn_init();
        !           122:        getdir();
        !           123:        gethome();      /* before anyone changes it */
        !           124:        CmdDb = malloc(strlen(gethome()) + 10);
        !           125:        strcpy(CmdDb,gethome());
        !           126:        strcat(CmdDb,"/cmds.doc");
        !           127:        InitBinds();
        !           128: }
        !           129: 
        !           130: 
        !           131: /* dummy routines. */
        !           132: 
        !           133: int dummy(){}
        !           134: 
        !           135: SIGRESULT (*signal(sig,func)) proto((int))
        !           136: int sig;
        !           137: SIGRESULT (*func) proto((int));
        !           138: {
        !           139:        return(&dummy);
        !           140: }
        !           141: 
        !           142: dorecover() {}
        !           143: 
        !           144: 
        !           145: /* Surrogate unix-style file i/o routines for Jove. These replace the
        !           146:    routines distributed in the libraries. They work with Jove, but may
        !           147:    not be general enough for other purposes. */
        !           148: 
        !           149: #include <io.h>
        !           150: #define NFILES 10
        !           151: 
        !           152: /* #define fsetup(p) { \
        !           153:  *     (p).ioCompletion = 0; \
        !           154:  *     (p).ioVRefNum = cur_vol; \
        !           155:  *     (p).ioDirID = cur_dir; \
        !           156:  *     (p).ioFVersNum = 0; \
        !           157:  * }
        !           158:  * #define isetup(p) {(p).ioCompletion = 0; (p).ioVRefNum = cur_vol;}
        !           159:  */
        !           160: 
        !           161: static int cur_vol;    /* Disk or volume number */
        !           162: static long cur_dir;   /* Directory number */
        !           163: static int cur_vref;   /* ugh.. Vref for volume + directory */
        !           164: 
        !           165: struct ftab {
        !           166:        int inuse;      /* 0 = closed 1 = binary 2 = text*/
        !           167:        int refnum;     /* Mac file reference number */
        !           168: } ft[NFILES];
        !           169: 
        !           170: fsetup(p)
        !           171: HParmBlkPtr p;
        !           172: {
        !           173:        byte_zero(p,sizeof(HParamBlockRec));
        !           174:        p->fileParam.ioVRefNum = cur_vol;
        !           175:        p->fileParam.ioDirID = cur_dir;
        !           176:        p->fileParam.ioFVersNum = 0;
        !           177: }
        !           178: 
        !           179: isetup(p)
        !           180: HIOParam *p;
        !           181: {
        !           182:        byte_zero(p,sizeof(HIOParam));
        !           183:        p->ioVRefNum = cur_vol;
        !           184: }
        !           185: 
        !           186: 
        !           187: /* Kludge to convert Macintosh error codes to something like Unix. */
        !           188: 
        !           189: static int cvt_err(err)        /* some of these don't make sense... */
        !           190: {
        !           191:        switch(err) {
        !           192:                case noErr: errno = 0; return(0);
        !           193:                case dirFulErr: errno = ENOSPC; break;
        !           194:                case dskFulErr: errno = ENOSPC; break;
        !           195:                case nsvErr: errno = ENOENT; break;
        !           196:                case ioErr: errno = EIO; break;
        !           197:                case bdNamErr: errno = EINVAL; break;
        !           198:                case fnOpnErr: errno = EBADF; break;    /* dubious... */
        !           199:                case eofErr: errno = ESPIPE; break;             /* ditto */
        !           200:                case posErr: errno = ESPIPE; break;
        !           201:                case mFulErr:
        !           202:                case tmfoErr:
        !           203:                case fnfErr: errno = ENOENT; break;
        !           204:                case wPrErr: errno = EROFS; break;
        !           205:                case fLckdErr: errno = EACCES; break;
        !           206:                case fBsyErr: errno = EBUSY; break;
        !           207:                case dupFNErr: errno = EEXIST; break;
        !           208:                case opWrErr:
        !           209:                case paramErr: errno = EINVAL; break;
        !           210:                case rfNumErr: errno = EBADF; break;
        !           211:                case gfpErr:
        !           212:                case volOffLinErr: errno = ENODEV; break;
        !           213:                case permErr: errno = EACCES; break;
        !           214:                case volOnLinErr: errno = ENODEV; break;
        !           215:                case nsDrvErr: errno = ENODEV; break;
        !           216:                case noMacDskErr: errno = EIO; break;
        !           217:                case extFSErr: errno = EIO; break;
        !           218:                case fsRnErr:
        !           219:                case badMDBErr:
        !           220:                case wrPermErr: errno = EPERM; break;
        !           221:                default: errno = ENOENT;
        !           222:        }
        !           223:        return(-1);
        !           224: }
        !           225: 
        !           226: static char *cvt_fnm(file)
        !           227: char *file;
        !           228: {
        !           229:        static char nm[255];
        !           230:        char *t;
        !           231: 
        !           232: 
        !           233:        if(*file == '/') strcpy(nm,file + 1); /* full path */
        !           234:        else {
        !           235:                if(strchr(file + 1, '/') != NULL)
        !           236:                        strcpy(nm,"/"); /* make a partial pathname */
        !           237:                else *nm = '\0';
        !           238:                strcat(nm,file);
        !           239:        }
        !           240:        t = nm;
        !           241:        while(*t) {
        !           242:                if(*t == '/') *t = ':';
        !           243:                t++;
        !           244:        }
        !           245:        return(nm);
        !           246: }
        !           247: 
        !           248: int creat(name,perm)   /* permission mode is irrelevant on a Mac */
        !           249: char *name;
        !           250: {
        !           251:        int fd, err;
        !           252:        char *nm;
        !           253:        HParamBlockRec p;
        !           254: 
        !           255:        if(is_dir(name)) {
        !           256:                errno = EACCES;
        !           257:                return(-1);
        !           258:        }
        !           259:        nm = cvt_fnm(name);     /* convert filename to Mac type name */
        !           260:        CtoPstr(nm);
        !           261:        for(fd = 0; fd < NFILES && ft[fd].inuse; fd++);
        !           262:        if(fd == NFILES) {
        !           263:                errno = EMFILE;
        !           264:                return(-1);
        !           265:        }
        !           266:        fsetup(&p);     /* try to delete it, whether it is there or not. */
        !           267:        p.fileParam.ioNamePtr = (StringPtr) nm;
        !           268:        if((err = PBHDelete(&p,0)) != noErr && err != fnfErr) return(cvt_err(err));
        !           269:        if(do_creat(&p,nm) != 0) return(-1);
        !           270:        else {
        !           271:                ft[fd].inuse++;
        !           272:                ft[fd].refnum = p.ioParam.ioRefNum;
        !           273:                return(fd + 1);
        !           274:        }
        !           275: }
        !           276: 
        !           277: int open(name,mode)
        !           278: char *name;
        !           279: {
        !           280:        int fd, err;
        !           281:        char *nm;
        !           282:        HParamBlockRec p;
        !           283: 
        !           284:        if(is_dir(name)) {
        !           285:                errno = EACCES;
        !           286:                return(-1);
        !           287:        }
        !           288: 
        !           289:        nm = cvt_fnm(name);     /* convert filename to Mac type name */
        !           290:        CtoPstr(nm);
        !           291:        for(fd = 0; fd < NFILES && ft[fd].inuse; fd++);
        !           292:        if(fd == NFILES) {
        !           293:                errno = EMFILE;
        !           294:                return(-1);
        !           295:        }
        !           296:        fsetup(&p);
        !           297:        if((mode & 3) == O_RDONLY) p.ioParam.ioPermssn = fsRdPerm;
        !           298:        if((mode & 3) == O_WRONLY) p.ioParam.ioPermssn = fsWrPerm;
        !           299:        if((mode & 3) == O_RDWR) p.ioParam.ioPermssn = fsRdWrPerm;
        !           300:        p.ioParam.ioNamePtr = (StringPtr) nm;
        !           301:        p.ioParam.ioMisc = 0;
        !           302:        if((err = PBHOpen(&p,0)) != noErr && err != fnfErr) return(cvt_err(err));
        !           303:        if(err == noErr && mode & O_CREAT && mode & O_EXCL) {
        !           304:                PBClose(&p,0);
        !           305:                errno = EEXIST;
        !           306:                return(-1);
        !           307:        }
        !           308:        if(err == fnfErr) {
        !           309:                if(mode & O_CREAT) {
        !           310:                        if(do_creat(&p,nm) != 0) return(-1);
        !           311:                } else {
        !           312:                        errno = ENOENT;
        !           313:                        return(-1);
        !           314:                }
        !           315:        }
        !           316:        ft[fd].inuse++;
        !           317:        ft[fd].refnum = p.ioParam.ioRefNum;
        !           318:        if(mode & O_APPEND)     p.ioParam.ioPosMode = fsFromLEOF;
        !           319:        else p.ioParam.ioPosMode = fsFromStart;
        !           320:        p.ioParam.ioPosOffset = 0;
        !           321:        if((err = PBSetFPos(&p,0)) != noErr) {
        !           322:                ft[fd].inuse = 0;
        !           323:                return(cvt_err(err));
        !           324:        }
        !           325:        errno = 0;
        !           326:        return(fd + 1);
        !           327: }
        !           328: 
        !           329: static int do_creat(p,nm)
        !           330: HParmBlkPtr p;
        !           331: char *nm;
        !           332: {
        !           333:        int err;
        !           334: 
        !           335:        fsetup(p);
        !           336:        p->fileParam.ioNamePtr = (StringPtr) nm;
        !           337:        if((err = PBHCreate(p,0)) != noErr) return(cvt_err(err));
        !           338:        fsetup(p);
        !           339:        p->fileParam.ioNamePtr = (StringPtr) nm;
        !           340:        p->fileParam.ioFDirIndex = 0;
        !           341:        if((err = PBHGetFInfo(p,0)) != noErr) return(cvt_err(err));
        !           342:        p->fileParam.ioDirID = cur_dir;
        !           343:        p->fileParam.ioFlFndrInfo.fdType = 'TEXT';
        !           344:        p->fileParam.ioFlFndrInfo.fdCreator = 'JV01';
        !           345:        p->fileParam.ioFlFndrInfo.fdFlags = 0;
        !           346:        p->fileParam.ioFVersNum = 0;
        !           347:        if((err = PBHSetFInfo(p,0)) != noErr) return(cvt_err(err));
        !           348:        fsetup(p);
        !           349:        p->ioParam.ioNamePtr = (StringPtr) nm;
        !           350:        p->ioParam.ioPermssn = fsRdWrPerm;
        !           351:        p->ioParam.ioMisc = 0;
        !           352:        if(cvt_err(PBHOpen(p,0))) return(-1);
        !           353:        return(0);
        !           354: }
        !           355: 
        !           356: 
        !           357: int close(fd)
        !           358: {
        !           359:        int err;
        !           360:        HParamBlockRec p;
        !           361: 
        !           362:        fsetup(&p);
        !           363:        p.ioParam.ioRefNum = ft[--fd].refnum;
        !           364:        ft[fd].inuse = 0;
        !           365: /*     if(cvt_err(PBFlushFile(&p,0)) < 0) return(-1);
        !           366:        fsetup(&p); */
        !           367:        if(cvt_err(PBClose(&p,0)) < 0) return(-1);
        !           368:        fsetup(&p);
        !           369:        p.ioParam.ioNamePtr = 0;
        !           370:        if(cvt_err(PBFlushVol(&p,0)) < 0) return(-1);
        !           371: }
        !           372: 
        !           373: int read(fd,buf,n)
        !           374: char *buf;
        !           375: unsigned n;
        !           376: {
        !           377:        int err;
        !           378:        IOParam p;
        !           379:        if(fd == 0) return(con_read(buf,n));
        !           380:        if(ft[--fd].inuse == 0) {
        !           381:                errno = EBADF;
        !           382:                return(-1);
        !           383:        }
        !           384:        isetup(&p);
        !           385:        p.ioRefNum = ft[fd].refnum;
        !           386:        p.ioBuffer = buf;
        !           387:        p.ioReqCount = n;
        !           388:        p.ioPosMode = fsFromMark;
        !           389:        p.ioPosOffset = 0;
        !           390:        if((err = PBRead(&p,0)) != noErr && err != eofErr) {
        !           391:                cvt_err(err);
        !           392:                return(-1);
        !           393:        }
        !           394:        while(n--) {
        !           395:                if(*buf == '\r') *buf = '\n';   /* convert from Mac style */
        !           396:                buf++;
        !           397:        }
        !           398:        errno = 0;
        !           399:        return(p.ioActCount);
        !           400: }
        !           401: 
        !           402: int write(fd,buf,n)
        !           403: char *buf;
        !           404: unsigned n;
        !           405: {
        !           406:        int err;
        !           407:        IOParam p;
        !           408:        char *obuf, *s;
        !           409: 
        !           410:        if(fd == 0) return(con_write(buf,n));
        !           411: 
        !           412:        s = obuf = malloc(n + 1);
        !           413:        if(obuf == 0)  return(-1);      /* shouldn't happen... */
        !           414:        if(ft[--fd].inuse == 0) {
        !           415:                errno = EBADF;
        !           416:                free(obuf);
        !           417:                return(-1);
        !           418:        }
        !           419:        isetup(&p);
        !           420:        p.ioRefNum = ft[fd].refnum;
        !           421:        p.ioBuffer = obuf;
        !           422:        p.ioReqCount = (long) n;
        !           423:        p.ioPosMode = fsFromMark;
        !           424:        p.ioPosOffset = 0L;
        !           425:        while(n--) {
        !           426:                if(*buf == '\n') *s = '\r';     /* make it look like Mac files */
        !           427:                else(*s = *buf);
        !           428:                buf++;
        !           429:                s++;
        !           430:        }
        !           431:        if((err = PBWrite(&p,0)) != noErr) {
        !           432:                free(obuf);
        !           433:                return(-1);
        !           434:        }
        !           435:        free(obuf);
        !           436:        return((int) p.ioActCount);
        !           437: }
        !           438: 
        !           439: long lseek(fd,offset,type)     /* The Mac version of this doesn't allocate new space. */
        !           440: long offset;
        !           441: unsigned type;
        !           442: {
        !           443:        int err;
        !           444:        long cur_mark, eof, new_mark;
        !           445:        IOParam p;
        !           446: 
        !           447:        if(ft[--fd].inuse == 0) {
        !           448:                errno = EBADF;
        !           449:                return(-1);
        !           450:        }
        !           451: 
        !           452:        isetup(&p);
        !           453:        p.ioRefNum = ft[fd].refnum;
        !           454:        if((err = PBGetFPos(&p,0)) != noErr) {
        !           455:                cvt_err(err);
        !           456:                return(-1);
        !           457:        }
        !           458:        cur_mark = p.ioPosOffset;
        !           459:        isetup(&p);
        !           460:        p.ioRefNum = ft[fd].refnum;
        !           461:        if((err = PBGetEOF(&p,0)) != noErr) {
        !           462:                cvt_err(err);
        !           463:                return(-1);
        !           464:        }
        !           465:        eof = (long) p.ioMisc;
        !           466:        switch(type) {
        !           467:                case 0 :
        !           468:                        new_mark = offset;
        !           469:                        break;
        !           470:                case 1 :
        !           471:                        new_mark = offset + cur_mark;
        !           472:                        break;
        !           473:                case 2 :
        !           474:                        new_mark = offset + eof;
        !           475:        }
        !           476:        if(new_mark > eof) {            /* need more space in file */
        !           477:                isetup(&p);
        !           478:                p.ioRefNum = ft[fd].refnum;
        !           479:                p.ioMisc = (Ptr) new_mark;
        !           480:                if((err = PBSetEOF(&p,0)) != noErr) {
        !           481:                        cvt_err(err);
        !           482:                        return(-1);
        !           483:                }
        !           484: /*             if((err = PBAllocContig(&p,0)) != noErr) {
        !           485:                        cvt_err(err);
        !           486:                        return(-1);
        !           487:                }*/
        !           488:        }
        !           489:        isetup(&p);
        !           490:        p.ioRefNum = ft[fd].refnum;
        !           491:        p.ioPosOffset = new_mark;
        !           492:        p.ioPosMode = fsFromStart;
        !           493:        if((err = PBSetFPos(&p,0)) != noErr) {
        !           494:                cvt_err(err);
        !           495:                return(-1);
        !           496:        }
        !           497:        errno = 0;
        !           498:        return(p.ioPosOffset);
        !           499: }
        !           500: 
        !           501: int unlink(name)
        !           502: char *name;
        !           503: {      int fd, err;
        !           504:        char *nm;
        !           505:        HParamBlockRec p;
        !           506: 
        !           507:        nm = cvt_fnm(name);     /* convert filename to Mac type name */
        !           508:        CtoPstr(nm);
        !           509:        fsetup(&p);     /* try to delete it, whether it is there or not. */
        !           510:        p.fileParam.ioNamePtr = (StringPtr) nm;
        !           511:        if((err = PBHDelete(&p,0)) != noErr && err != fnfErr) return(cvt_err(err));
        !           512:        return;
        !           513: }
        !           514: 
        !           515: /* Console read and write routines */
        !           516: 
        !           517: static int con_write(buf,size)
        !           518: unsigned  size;
        !           519: char *buf;
        !           520: {
        !           521:        while(size--) putp(*buf++);
        !           522:        return(size);
        !           523: }
        !           524: 
        !           525: static int con_read(buf,size)
        !           526: unsigned size;
        !           527: char *buf;
        !           528: {
        !           529:        unsigned n;
        !           530:        int p;
        !           531: 
        !           532: 
        !           533:        n = 0;
        !           534:        do {
        !           535:                p = rawgetc();
        !           536: #ifdef O_META
        !           537:                if(p & 0x7f) p &= 0x7f;         /* was normal ascii char */
        !           538: #endif
        !           539:                *buf++ = p;
        !           540:                n++;
        !           541:        } while (rawchkc() && n <= size);
        !           542:        return(n);
        !           543: }
        !           544: 
        !           545: 
        !           546: /* This didn't seem to be any place else */
        !           547: 
        !           548: int abs(n)
        !           549: int n;
        !           550: {
        !           551:        return(n >= 0 ? n : -n);
        !           552: 
        !           553: }
        !           554: 
        !           555: /* Simplified stat() routine emulates what is needed most. */
        !           556: 
        !           557: int stat(fname,buf)
        !           558: char *fname;
        !           559: struct stat *buf;
        !           560: {
        !           561:        CInfoPBRec p;
        !           562:        char *nm;
        !           563: 
        !           564:        nm = cvt_fnm(fname);
        !           565:        CtoPstr(nm);
        !           566:        byte_zero(&p,sizeof(CInfoPBRec));
        !           567:        p.hFileInfo.ioCompletion = 0;
        !           568:        p.hFileInfo.ioNamePtr = (StringPtr) nm;
        !           569:        p.hFileInfo.ioFVersNum = 0;
        !           570:        p.hFileInfo.ioFDirIndex = 0;
        !           571:        p.hFileInfo.ioVRefNum = cur_vol;
        !           572:        p.hFileInfo.ioDirID = cur_dir;
        !           573: 
        !           574:        switch (PBGetCatInfo(&p,0)) {
        !           575: 
        !           576:                case noErr :    errno = 0;
        !           577:                                                break;
        !           578:                case nsvErr:
        !           579:                case paramErr:
        !           580:                case bdNamErr :
        !           581:                case fnfErr:    errno = ENOENT;
        !           582:                                                break;
        !           583:                case ioErr:             errno = EIO;
        !           584:                                                break;
        !           585:                default :               errno = ENOENT;
        !           586:                                                break;
        !           587:        }
        !           588:        buf->st_dev = p.hFileInfo.ioVRefNum + 1;        /* don't want 0 */
        !           589:        buf->st_ino = p.hFileInfo.ioDirID;
        !           590:        buf->st_size = p.hFileInfo.ioFlLgLen;
        !           591:        buf->st_mtime = p.hFileInfo.ioFlMdDat;
        !           592:        buf->st_mode = (p.hFileInfo.ioFlAttrib & 0x10) ? S_IFDIR : 0;
        !           593:        PtoCstr(nm);
        !           594:        return(errno == 0 ? 0 : -1);
        !           595: }
        !           596: 
        !           597: int is_dir(fname)
        !           598: char *fname;
        !           599: {
        !           600:        struct stat s;
        !           601:        if((stat(fname,&s) == 0) && (s.st_mode & S_IFDIR)) return(1);
        !           602:        return(0);
        !           603: }
        !           604: 
        !           605: /* Directory related routines. Jove keeps track of the true Volume (disk) number and
        !           606:    directory number, and avoids "Working Directory Reference Numbers", which are
        !           607:    confusing. */
        !           608: 
        !           609: static int getdir()    /* call this only once, during startup. */
        !           610: {
        !           611:        WDPBRec p;
        !           612: 
        !           613:        p.ioCompletion = 0;
        !           614:        p.ioNamePtr = 0;
        !           615:        if(PBHGetVol(&p,0) != noErr) return(-1);        /* BIG trouble */
        !           616:        cur_vol = p.ioWDVRefNum;
        !           617:        cur_dir = p.ioWDDirID;
        !           618:        SFSaveDisk = 0 - cur_vol;       /* these are for SF dialogs */
        !           619:        CurDirStore = cur_dir;
        !           620: }
        !           621: 
        !           622: static int setdir(vol,dir)
        !           623: long dir;
        !           624: {
        !           625:        WDPBRec p;
        !           626: 
        !           627:        p.ioCompletion = 0;
        !           628:        p.ioNamePtr = 0;
        !           629:        p.ioVRefNum = vol;
        !           630:        p.ioWDDirID = dir;
        !           631:        if(PBHSetVol(&p,0) != noErr) return(-1);
        !           632:        cur_vol = vol;
        !           633:        cur_dir = dir;
        !           634:        SFSaveDisk = 0 - vol;   /* these are for SF dialogs */
        !           635:        CurDirStore = dir;
        !           636: 
        !           637: 
        !           638: }
        !           639: 
        !           640: int chdir(dir)
        !           641: char *dir;
        !           642: {
        !           643:        CInfoPBRec d;
        !           644:        WDPBRec p;
        !           645:        char *t;
        !           646:        char *nm;
        !           647: 
        !           648:        if(strcmp(dir,"/") == 0) return(-1); /* There is no root... */
        !           649:        nm = malloc(strlen(dir) + 2);
        !           650:        if(nm == 0) return(-1);
        !           651: 
        !           652:        strcpy(nm,dir);
        !           653:        t = nm;
        !           654:        while(*t) {
        !           655:                if(*t == '/') *t = ':';
        !           656:                t++;
        !           657:        }
        !           658:        t = nm;
        !           659:        while(*t == ':') t++;   /*get rid of initial slashes */
        !           660:        strcat(nm,":");
        !           661:        CtoPstr(t);
        !           662: 
        !           663:        d.dirInfo.ioCompletion = 0;                     /* get the directory number */
        !           664:        d.dirInfo.ioNamePtr = (StringPtr) t;
        !           665:        d.dirInfo.ioVRefNum = cur_vol;
        !           666:        d.dirInfo.ioFDirIndex = 0;
        !           667:        d.dirInfo.ioDrDirID = 0;
        !           668:        PBGetCatInfo(&d,0);
        !           669:        free(nm);
        !           670:        if(d.dirInfo.ioResult != noErr || ((d.dirInfo.ioFlAttrib & 0x10) == 0)) return(-1);
        !           671:        if(setdir(d.dirInfo.ioVRefNum,d.dirInfo.ioDrDirID) < 0)return(-1);
        !           672:        return(0);
        !           673: }
        !           674: 
        !           675: /* Scandir returns the number of entries or -1 if the directory cannot
        !           676:    be opened or malloc fails. */
        !           677: 
        !           678: int scandir(dir, nmptr, qualify, sorter) /* this function has NOT been debugged */
        !           679: char   *dir;
        !           680: char   ***nmptr;
        !           681: int    (*qualify) proto((char *));
        !           682: int    (*sorter) proto((UnivConstPtr, UnivConstPtr));
        !           683: {
        !           684:        CInfoPBRec d;
        !           685:        Str255 buf;
        !           686:        long DirID;
        !           687:        char    **ourarray, *nm, *t;
        !           688:        unsigned int nalloc = 10,
        !           689:                        nentries = 0, index = 1;
        !           690:        char *getwd();
        !           691: 
        !           692:        if(strcmp(dir,"/") == 0) return(-1); /* There is no root... */
        !           693:        if(strcmp(dir,".") == 0) dir = getwd();
        !           694:        nm = malloc(strlen(dir) + 2);
        !           695:        if(nm == 0) return(-1);
        !           696: 
        !           697:        strcpy(nm,dir);
        !           698:        t = nm;
        !           699:        while(*t) {
        !           700:                if(*t == '/') *t = ':';
        !           701:                t++;
        !           702:        }
        !           703:        t = nm;
        !           704:        while(*t == ':') t++;   /*get rid of initial slashes */
        !           705:        strcat(nm,":");
        !           706:        CtoPstr(t);
        !           707: 
        !           708:        byte_zero(&d,sizeof(CInfoPBRec));
        !           709:        d.dirInfo.ioCompletion = 0;                     /* get the directory number */
        !           710:        d.dirInfo.ioNamePtr = (StringPtr) t;
        !           711:        d.dirInfo.ioVRefNum = cur_vol;
        !           712:        d.dirInfo.ioFDirIndex = 0;
        !           713:        d.dirInfo.ioDrDirID = 0;
        !           714:        PBGetCatInfo(&d,0);
        !           715:        PtoCstr(t);
        !           716:        free(nm);
        !           717:        if(d.dirInfo.ioResult != noErr || ((d.dirInfo.ioFlAttrib & 0x10) == 0)) return(-1);
        !           718:        DirID = d.dirInfo.ioDrDirID;
        !           719:        if ((ourarray = (char **) malloc(nalloc * sizeof (char *))) == 0)
        !           720: memfail:       complain("[Malloc failed: cannot scandir]");
        !           721:        while (1) {
        !           722:                byte_zero(&d,sizeof(CInfoPBRec));
        !           723:                d.dirInfo.ioCompletion = (long) 0;
        !           724:                d.dirInfo.ioVRefNum = cur_vol;
        !           725:                d.dirInfo.ioFVersNum = 0;
        !           726:                d.dirInfo.ioNamePtr = buf;
        !           727:                d.dirInfo.ioFDirIndex = index++;
        !           728:                d.dirInfo.ioVRefNum = cur_vol;
        !           729:                d.dirInfo.ioDrDirID = DirID;
        !           730:                if(PBGetCatInfo(&d,0) != noErr) break;  /* we are done, then */
        !           731:                PtoCstr((char *) buf);
        !           732: /*             if(d.dirInfo.ioFlAttrib & 0x10) strcat(buf,"/");*/
        !           733:                if (qualify != 0 && (*qualify)((char *) buf) == 0)
        !           734:                        continue;
        !           735:                if (nentries == nalloc) {
        !           736:                        ourarray = (char **) realloc((char *) ourarray, (nalloc += 10) * sizeof (char *));
        !           737:                        if (ourarray == 0)
        !           738:                                goto memfail;
        !           739:                }
        !           740:                ourarray[nentries] = (char *) malloc(strlen(buf)+1);
        !           741:                null_ncpy(ourarray[nentries], (char *) buf, strlen((char *) buf));
        !           742:                nentries += 1;
        !           743:        }
        !           744:        if ((nentries + 1) != nalloc)
        !           745:                ourarray = (char **) realloc((char *) ourarray,
        !           746:                                        ((nentries + 1) * sizeof (char *)));
        !           747:        if (sorter != 0)
        !           748:                qsort((char *) ourarray, nentries, sizeof (char **), sorter);
        !           749:        *nmptr = ourarray;
        !           750:        ourarray[nentries] = 0;         /* guaranteed 0 pointer */
        !           751:        return nentries;
        !           752: }
        !           753: 
        !           754: void freedir(dir, nentries)
        !           755: char ***dir;
        !           756: int nentries;
        !           757: {
        !           758:        char **ptr = *dir;
        !           759:        while(nentries--) free(*ptr++);
        !           760: }
        !           761: 
        !           762: int
        !           763: alphacomp(a, b)
        !           764: UnivConstPtr   a,
        !           765:        b;
        !           766: {
        !           767:        return strcmp(*(const char **)a, *(const char **)b);
        !           768: }
        !           769: 
        !           770: int
        !           771: chkCWD(name)   /* eventually, may check validity of cwd */
        !           772: char *name;
        !           773: {
        !           774:        return(1);
        !           775: }
        !           776: 
        !           777: 
        !           778: char *getwd()
        !           779: {
        !           780:        CInfoPBRec d;
        !           781:        static char ret[255];
        !           782:        char nm[50], tmp[255];
        !           783: 
        !           784:        ret[0] = '\0';
        !           785:        d.dirInfo.ioDrDirID = cur_dir;
        !           786:        for(;;) {
        !           787:                d.dirInfo.ioCompletion = 0;
        !           788:                d.dirInfo.ioNamePtr = (StringPtr) nm;
        !           789:                d.dirInfo.ioVRefNum = cur_vol;
        !           790:                d.dirInfo.ioFDirIndex = -1;
        !           791: 
        !           792:                PBGetCatInfo(&d,0);
        !           793:                if(d.dirInfo.ioResult != noErr) return(0);
        !           794:                PtoCstr((char *) nm);
        !           795:                strcpy(tmp,ret);
        !           796:                strcpy(ret,"/");
        !           797:                strcat(ret,nm);
        !           798:                strcat(ret,tmp);
        !           799:                if(d.dirInfo.ioDrDirID == 2) break;     /* home directory */
        !           800:                d.dirInfo.ioDrDirID = d.dirInfo.ioDrParID;
        !           801:        }
        !           802:        return(ret);
        !           803: }
        !           804: 
        !           805: static char *gethome()         /* this will be startup directory */
        !           806: {
        !           807:        static char *ret = 0;
        !           808: 
        !           809: 
        !           810:        if(ret == 0) {
        !           811:                char *item = getwd();
        !           812:                ret = malloc(strlen(item)+1);
        !           813:                strcpy(ret,item);
        !           814:        }
        !           815:        return(ret);
        !           816: }
        !           817: 
        !           818: 
        !           819: 
        !           820: /* Routines that put up and manipulate the "About Jove" dialog. */
        !           821: 
        !           822: 
        !           823: /* (ORIGINALLY IN) about_j.c. */
        !           824: 
        !           825: 
        !           826: #define DLOGNAME "\pABOUT_JDLOG"
        !           827: 
        !           828: #define DONE_ITEM 1
        !           829: #define LIST_ITEM 2
        !           830: 
        !           831: 
        !           832: #define DWIDTH 460             /* there should be an easy way to get this */
        !           833: #define DHEIGHT 240            /* from the resource file! */
        !           834: 
        !           835: WindowPtr makedisplay();
        !           836: ListHandle makelist();
        !           837: 
        !           838: 
        !           839: static WindowPtr theWindow;
        !           840: static ListHandle theList;
        !           841: static Rect theListRect;
        !           842: static EventRecord theEvent;
        !           843: 
        !           844: 
        !           845: 
        !           846: static void about_j()
        !           847: {
        !           848:        void do_list(), do_events();
        !           849: 
        !           850:        WindowPtr OldWindow;
        !           851: 
        !           852:        GetPort(&OldWindow);
        !           853: 
        !           854:        if((theWindow = makedisplay()) == 0) return;
        !           855:        SetPort(theWindow);
        !           856:        if(theList = makelist()) {
        !           857:                LActivate(1,theList);
        !           858:                do_list();
        !           859:                ShowWindow(theWindow);
        !           860:                do_events();
        !           861:        }
        !           862:        SetPort(OldWindow);
        !           863:        LDispose(theList);
        !           864:        DisposDialog(theWindow);
        !           865: 
        !           866:        return;
        !           867: }
        !           868: 
        !           869: 
        !           870: static WindowPtr makedisplay()
        !           871: {
        !           872:        static int dlogid = 0;
        !           873:        DialogPtr theDialog;
        !           874:        Handle theHandle;
        !           875:        Handle theResource;
        !           876:        Str255 buf;
        !           877:        long itemType;
        !           878:        Rect theRect;
        !           879:        short dh,dv;    /* to center dialog on the screen */
        !           880:        Str255 nostring;
        !           881: 
        !           882:        if(dlogid == 0) {
        !           883:                if((theResource = GetNamedResource('DLOG',DLOGNAME)) == 0)
        !           884:                        return((WindowPtr) 0);
        !           885:                itemType = 'DLOG';
        !           886:                GetResInfo(theResource,&dlogid,&itemType,buf);
        !           887:        }
        !           888: 
        !           889:        theDialog = GetNewDialog(dlogid,(long) 0,(WindowPtr) -1);
        !           890:        strcpy((char *) nostring,"\p");
        !           891:        ParamText("\pMacJove - Copyright (C) 1986, 1987, 1988 J. Payne, K. Gegenfurtner,",
        !           892:        "\pK. Mitchum. Portions (C) THINK Technologies, Inc.",nostring,nostring);
        !           893: 
        !           894:        dh = screenBits.bounds.left + (screenBits.bounds.right - DWIDTH) / 2;
        !           895:        dv = screenBits.bounds.top  + (screenBits.bounds.bottom - DHEIGHT) / 2;
        !           896:        MoveWindow((WindowPtr)theDialog,dh,dv,0);
        !           897:        ShowWindow((WindowPtr)theDialog);
        !           898: 
        !           899: 
        !           900:        GetDItem(theDialog,LIST_ITEM,&itemType,&theHandle,&theRect);
        !           901:        theListRect = theRect;
        !           902:        theListRect.right -= 15;
        !           903:        ((WindowPtr)theDialog)->txFont = FONT;
        !           904:        ((WindowPtr)theDialog)->txSize = TEXTSIZE;
        !           905: 
        !           906:        return((WindowPtr) theDialog);
        !           907: }
        !           908: 
        !           909: static void do_display()               /* draw necessary controls, lines */
        !           910: {
        !           911:        Rect rViewF;            /* framing rect for list */
        !           912:        int offset;
        !           913: 
        !           914:        rViewF = theListRect;
        !           915: 
        !           916:        rViewF.left--;
        !           917:        rViewF.top--;
        !           918:        rViewF.right++;
        !           919:        rViewF.bottom++;
        !           920:        FrameRect(&rViewF);
        !           921: 
        !           922:        DrawControls(theWindow);
        !           923: 
        !           924: }
        !           925: 
        !           926: static ListHandle makelist()
        !           927: {
        !           928:        Point csize;
        !           929:        Rect dataBounds, rView; /* list boundaries */
        !           930: 
        !           931:        csize.h = csize.v = 0;
        !           932:        SetRect(&dataBounds,0,0,1,0);
        !           933:        return(LNew(&theListRect,&dataBounds,csize,0,theWindow,0,0,0,1));
        !           934: }
        !           935: 
        !           936: static void do_list()
        !           937: {
        !           938:        void printbind();
        !           939: 
        !           940:        int row, col;
        !           941:        struct cmd *f;
        !           942:        Str255 buf;
        !           943:        Point theCell;
        !           944: 
        !           945:        theCell.h = 0;
        !           946: 
        !           947:        for(f = commands, row = 0; f->Name; f++, row++) {
        !           948:                LAddRow(1,row,theList);
        !           949:                theCell.v = row;
        !           950: 
        !           951:                printbind(f,buf);
        !           952:                strcat(buf,f->Name);
        !           953:                LSetCell(buf,strlen((char *)buf),theCell,theList);
        !           954: 
        !           955:        }
        !           956: }
        !           957: static void printbind(f,buf)
        !           958: struct cmd *f;
        !           959: char *buf;
        !           960: {
        !           961:        char c;
        !           962: 
        !           963:        if(f->c_map == 0 || (c = f->c_key) == 0x7f) {
        !           964:                strcpy(buf,"        ");
        !           965:                return;
        !           966:        }
        !           967:        switch(f->c_map) {
        !           968:                case F_MAINMAP :
        !           969:                        strcpy(buf,"     ");
        !           970:                        break;
        !           971: 
        !           972:                case F_PREF1MAP :
        !           973:                        strcpy(buf," ESC ");
        !           974:                        break;
        !           975: 
        !           976:                case F_PREF2MAP :
        !           977:                        strcpy(buf,"  ^X ");
        !           978:                        break;
        !           979:        }
        !           980:        if(c < ' ') {
        !           981:                buf[5] = '^';           /* control char */
        !           982:                c |= 0x40;
        !           983:        }
        !           984:        else buf[5] = ' ';
        !           985:        if(c >= 'a' && c<= 'z') c &= 0x5f;
        !           986:        buf[6] = c;
        !           987:        buf[7] = ' ';
        !           988:        buf[8] = '\0';
        !           989: }
        !           990: 
        !           991: 
        !           992: 
        !           993: static pascal Boolean ProcFilter(theDialog,event,itemHit)
        !           994: DialogPtr theDialog;
        !           995: EventRecord *event;
        !           996: int *itemHit;
        !           997: {
        !           998:        theEvent = *event;
        !           999:        if(theEvent.what == keyDown && theEvent.message & charCodeMask == '\r') {
        !          1000:                *itemHit = 1;
        !          1001:                return(TRUE);
        !          1002:        }
        !          1003:        if(theEvent.what == activateEvt && (WindowPtr) theEvent.message == theWindow) {
        !          1004:                LDoDraw(1,theList);
        !          1005:                LActivate(1,theList);
        !          1006:        }
        !          1007:        if(theEvent.what == updateEvt && (WindowPtr) theEvent.message == theWindow) {
        !          1008:                BeginUpdate(theWindow);
        !          1009:                do_display();
        !          1010:                DrawDialog(theWindow);
        !          1011:                LUpdate((GrafPtr) theWindow->visRgn,theList);
        !          1012:                EndUpdate(theWindow);
        !          1013:        }
        !          1014: 
        !          1015:        return(FALSE);
        !          1016: }
        !          1017: 
        !          1018: 
        !          1019: void do_events()
        !          1020: {
        !          1021:        int item,done;
        !          1022:        Point p;
        !          1023: 
        !          1024:        done = 0;
        !          1025: 
        !          1026:        while(!done) {
        !          1027:                ModalDialog(ProcFilter,&item);
        !          1028:                switch(item) {
        !          1029:                        case DONE_ITEM :
        !          1030:                                done = 1;
        !          1031:                        case LIST_ITEM :
        !          1032:                                p = theEvent.where;
        !          1033:                                GlobalToLocal(&p);
        !          1034:                                LClick(p,theEvent.modifiers,theList);
        !          1035:                }
        !          1036:        }
        !          1037: }
        !          1038: 
        !          1039: /* Window and Control related routines. */
        !          1040: 
        !          1041: /* (ORIGINALLY IN) tcon.c.
        !          1042:    control handler routines for Jove. K. Mitchum 12/86 */
        !          1043: 
        !          1044: 
        !          1045: #define MINC 0
        !          1046: #define MAXC ((int)100)
        !          1047: #define INITC 0
        !          1048: #define EVENTLIST (mDownMask | keyDownMask )
        !          1049: 
        !          1050: extern int UpdModLine;
        !          1051: extern long GetCRefCon();      /* omitted in ControlMgr.h */
        !          1052: 
        !          1053: static Point p;
        !          1054: static intext; /* mouse down in jove text */
        !          1055: 
        !          1056: void docontrols()      /* called from redisplay routines */
        !          1057: {
        !          1058:        void MakeScrollBar(),
        !          1059:                AdjustScrollBar(),
        !          1060:                drawfluff();
        !          1061: 
        !          1062:        Window *w;
        !          1063:        int top;
        !          1064: 
        !          1065:        w = fwind;
        !          1066:        top = 0;
        !          1067:        do {
        !          1068:                if(w->w_control) HideControl(w->w_control);
        !          1069:                w = w->w_next;
        !          1070:        } while (w != fwind);
        !          1071:        w = fwind;
        !          1072:        do {
        !          1073:                w->w_topline = top;
        !          1074:                if(w->w_control) AdjustScrollBar(w);
        !          1075:                else MakeScrollBar(w);
        !          1076:                ShowControl(w->w_control);
        !          1077:                top += w->w_height;
        !          1078:                w = w->w_next;
        !          1079:        } while(w != fwind);
        !          1080:        Windchange = 0;
        !          1081:        drawfluff();
        !          1082: }
        !          1083: 
        !          1084: 
        !          1085: void MakeScrollBar(w)  /* set up control */
        !          1086: Window *w;
        !          1087: {
        !          1088:        Rect BarRect;
        !          1089:        int wheight, wtop;
        !          1090: 
        !          1091:        WindowPtr window = theScreen;
        !          1092:        wheight = w->w_height;
        !          1093:        wtop = w->w_topline;
        !          1094:        SetRect(&BarRect,window->portRect.right - SCROLLWIDTH + 1,
        !          1095:                window->portRect.top -2 + wtop * HEIGHT,
        !          1096:                window->portRect.right +1,
        !          1097:                window->portRect.top + ((wheight + wtop) * HEIGHT + 1));
        !          1098:                w->w_control = ((char **) NewControl(window,&BarRect,"/psbar",1,INITC,
        !          1099:                MINC,MAXC,scrollBarProc,w));
        !          1100: }
        !          1101: 
        !          1102: void AdjustScrollBar(w)        /* redo existing control */
        !          1103: Window *w;
        !          1104: {
        !          1105:        int wtop,wheight;
        !          1106:        ControlHandle handle;
        !          1107:        WindowPtr window;
        !          1108: 
        !          1109:        handle = (ControlHandle) w->w_control;
        !          1110:        wtop = w->w_topline;
        !          1111:        wheight = w->w_height;
        !          1112:        window = (*handle)->contrlOwner;
        !          1113: 
        !          1114:        if(handle == 0) return;
        !          1115: 
        !          1116:        SizeControl(handle,SCROLLWIDTH,wheight * HEIGHT + 1);
        !          1117: 
        !          1118:        MoveControl(handle,window->portRect.right - SCROLLWIDTH + 1,
        !          1119:                window->portRect.top -1 + wtop * HEIGHT);
        !          1120: 
        !          1121: }
        !          1122: 
        !          1123: void SetScrollBar(handle)      /* set value of the bar */
        !          1124: ControlHandle handle;
        !          1125: {
        !          1126: 
        !          1127:        SetCtlValue(handle,ltoc());
        !          1128: }
        !          1129: 
        !          1130: static void drawfluff()                /* draw controls and dividers */
        !          1131: {
        !          1132:        Window *w = fwind;
        !          1133: 
        !          1134:        DrawControls(theScreen);
        !          1135:        DrawGrowIcon(theScreen);
        !          1136: }
        !          1137: 
        !          1138: void RemoveScrollBar(w)
        !          1139: Window *w;
        !          1140: {
        !          1141:        if(w->w_control) DisposeControl(w->w_control);
        !          1142:        w->w_control = 0;
        !          1143: 
        !          1144: }
        !          1145: 
        !          1146: static pascal void DScroll(control,part)
        !          1147: ControlHandle control;
        !          1148: int part;
        !          1149: {
        !          1150:        DownScroll();
        !          1151:        redisplay();
        !          1152: }
        !          1153: 
        !          1154: static pascal void UScroll(control,part)
        !          1155: ControlHandle control;
        !          1156: int part;
        !          1157: {
        !          1158:        UpScroll();
        !          1159:        redisplay();
        !          1160: }
        !          1161: 
        !          1162: static pascal void NPage(control,part)
        !          1163: ControlHandle control;
        !          1164: int part;
        !          1165: {      NextPage();
        !          1166:        redisplay();
        !          1167: }
        !          1168: 
        !          1169: static pascal void PPage(control,part)
        !          1170: ControlHandle control;
        !          1171: int part;
        !          1172: {      PrevPage();
        !          1173:        redisplay();
        !          1174: }
        !          1175: 
        !          1176: static long npos;      /* number of lines in buffer */
        !          1177: 
        !          1178: static int ltoc()      /* calculate ctlvalue for line position */
        !          1179: {
        !          1180:        register long ipos;
        !          1181:        register Line   *lp = curbuf->b_first;
        !          1182: 
        !          1183:        for (npos = 1; lp ; npos++, lp = lp->l_next)  {
        !          1184:                if(lp == curline) ipos = npos;
        !          1185:        }
        !          1186:        return((int) ((ipos * MAXC) / npos));
        !          1187: }
        !          1188: 
        !          1189: static Line *ctol(ctlv)        /* find buffer line for ctlvalue */
        !          1190: int ctlv;
        !          1191: {
        !          1192: extern char *itoa();
        !          1193:        register long ipos;
        !          1194:        register Line   *lp = curbuf->b_first;
        !          1195: 
        !          1196:        ipos = (npos * ctlv)/MAXC;
        !          1197:        while (ipos-- && lp->l_next) lp = lp->l_next;
        !          1198:        return(lp);
        !          1199: }
        !          1200: 
        !          1201: static void doWind(event,window)
        !          1202: EventRecord *event;
        !          1203: WindowPtr window;
        !          1204: {
        !          1205: #define track() TrackControl(whichControl,p,(ProcPtr) 0)
        !          1206: 
        !          1207:        ControlHandle whichControl;
        !          1208:        Window *jwind, *cwind;
        !          1209:        int notcurwind;
        !          1210:        int cpart;      /* control part */
        !          1211:        int oldval,newval,thumb = 0;
        !          1212: 
        !          1213:        p = event->where;
        !          1214:        intext = 0;
        !          1215:        notcurwind = 0;
        !          1216:        GlobalToLocal(&p);
        !          1217: 
        !          1218:        if(event->what == mouseDown) {
        !          1219:                if((cpart = FindControl(p,window,&whichControl)) == 0) return;
        !          1220:                if((jwind = (Window *) (*whichControl)->contrlRfCon) !=  curwind) {
        !          1221:                        notcurwind++;
        !          1222:                        cwind = curwind;
        !          1223:                        SetWind(jwind);
        !          1224:                }
        !          1225:                switch (cpart) {
        !          1226:                        case inUpButton :       TrackControl(whichControl,p,(ProcPtr) DScroll); break;
        !          1227:                        case inDownButton :     TrackControl(whichControl,p,(ProcPtr) UScroll); break;
        !          1228:                        case inPageUp :         TrackControl(whichControl,p,(ProcPtr) PPage); break;
        !          1229:                        case inPageDown :       TrackControl(whichControl,p,(ProcPtr) NPage); break;
        !          1230:                        case inThumb :          if(track()) {
        !          1231:                                                                        newval = GetCtlValue(whichControl);
        !          1232: 
        !          1233:                                                                        if(newval == MAXC) Eof();
        !          1234:                                                                        else if(newval == MINC) Bof();
        !          1235:                                                                        else SetLine(ctol(newval));
        !          1236:                                                                }
        !          1237:                                                                break;
        !          1238: 
        !          1239:                }
        !          1240:                if(notcurwind) {
        !          1241:                        SetWind(cwind);
        !          1242:                        redisplay();
        !          1243:                }
        !          1244:                redisplay();    /* again, to set the cursor */
        !          1245:        }
        !          1246:        else {
        !          1247:                if(findtext()) redisplay();
        !          1248:        }
        !          1249: }
        !          1250: 
        !          1251: #define std_state(w) (*((WStateData **)((WindowPeek)((w)))->dataHandle))->stdState
        !          1252: #define user_state(w) (*((WStateData **)((WindowPeek)((w)))->dataHandle))->userState
        !          1253: 
        !          1254: static void doDrag(event,window)
        !          1255: EventRecord *event;
        !          1256: WindowPtr window;
        !          1257: {
        !          1258:        Rect old_std;
        !          1259:        
        !          1260:        old_std = std_state(window);
        !          1261:                
        !          1262: 
        !          1263:        DragWindow(window, event->where, &LimitRect);
        !          1264:        if(wc == &wc_std) {
        !          1265:                wc_user = wc_std;
        !          1266:                user_state(theScreen) = std_state(theScreen);
        !          1267:                ZoomWindow(window,7,1);
        !          1268:                wc = &wc_user;
        !          1269:                Reset_std();
        !          1270:        }
        !          1271: }
        !          1272: 
        !          1273: static void doGrow(event,window)
        !          1274: EventRecord *event;
        !          1275: WindowPtr window;
        !          1276: {
        !          1277:        long size;
        !          1278: 
        !          1279:        /* zero means user didn't change anything */
        !          1280:        if(size = GrowWindow(window, event->where, &LimitRect)) {
        !          1281:                if(wc == &wc_std) {
        !          1282:                        wc_user = wc_std;
        !          1283:                        user_state(theScreen) = std_state(theScreen);
        !          1284:                        ZoomWindow(window,7,1);
        !          1285:                        wc = &wc_user;
        !          1286:                        Reset_std();
        !          1287:                }
        !          1288:                if(wc_adjust(LoWord(size),HiWord(size),wc,0)) {
        !          1289:                        EraseRect(&window->portRect);
        !          1290:                        SizeWindow(window,wc->w_width,wc->w_height,TRUE);
        !          1291:                        win_reshape();  /* no signals here... */
        !          1292:                }
        !          1293:        }
        !          1294: }
        !          1295: 
        !          1296: static void doZoomIn(event,window)
        !          1297: EventRecord *event;
        !          1298: WindowPtr window;
        !          1299: {
        !          1300:        if(TrackBox(window, event->where, 7) == TRUE){
        !          1301:                        EraseRect(&window->portRect);
        !          1302:                        ZoomWindow(window,7,1);
        !          1303:                        wc = &wc_user;
        !          1304:                        win_reshape();  /* we do our own toggle, not ZoomWindow() */
        !          1305:                }       
        !          1306: }
        !          1307: static void doZoomOut(event,window)
        !          1308: EventRecord *event;
        !          1309: WindowPtr window;
        !          1310: {
        !          1311:        if(TrackBox(window, event->where, 8) == TRUE) {
        !          1312:                        EraseRect(&window->portRect);
        !          1313:                        ZoomWindow(window,8,1);
        !          1314:                        wc = &wc_std;
        !          1315:                        win_reshape();  /* we do our own toggle, not ZoomWindow() */
        !          1316:                }       
        !          1317: }
        !          1318: 
        !          1319: static void doGoAway(event,window)
        !          1320: EventRecord *event;
        !          1321: WindowPtr window;
        !          1322: {
        !          1323:        if(TrackGoAway(window, event->where) == TRUE) Leave();
        !          1324: }
        !          1325: 
        !          1326: static Window *rtowind(row)    /* return jove window row is in */
        !          1327: int row;
        !          1328: {
        !          1329:        Window *w = fwind;
        !          1330: 
        !          1331:        do {
        !          1332:                if((w->w_topline <= row) && ((w->w_height + w->w_topline) > row))
        !          1333:                        return(w);
        !          1334:                w = w->w_next;
        !          1335:        } while(w != fwind);
        !          1336:        return(0);
        !          1337: }
        !          1338: 
        !          1339: static Line *windtol(w,row)            /* return line for row in window */
        !          1340: Window *w;
        !          1341: int row;
        !          1342: {
        !          1343:        Line *l = w->w_top;
        !          1344: 
        !          1345:        while(row--) if((l = l->l_next) == 0) return(0);
        !          1346:        return(l);
        !          1347: }
        !          1348: 
        !          1349: 
        !          1350: static int findtext()          /* locate and move the point to match the mouse */
        !          1351: {
        !          1352:        int row,col;
        !          1353:        long ticks;
        !          1354:        EventRecord event;
        !          1355:        Window *w;
        !          1356:        Line *l;
        !          1357:        
        !          1358:        ticks = Ticks;
        !          1359:        ptoxy(p,&row,&col);
        !          1360:        if((w = rtowind(row)) == 0) return(0);
        !          1361:        if(w != curwind) SetWind(w);
        !          1362:        row -= w->w_topline;            /* now have row number in window */
        !          1363:        if(row >= w->w_height -1) return(0);
        !          1364:        if((l = windtol(w,row)) == 0) return(0);
        !          1365:        if(l->l_dline == 0) return(0);
        !          1366:        this_cmd = LINECMD;
        !          1367:        SetLine(l);             /* Curline is in linebuf now */
        !          1368:        if(w->w_flags & W_NUMLINES) col -= 8;   /* adjust for line numbers */
        !          1369:        if(col < 0) col = 0;
        !          1370:        curchar = how_far(curline, col);
        !          1371:        do {
        !          1372:                if(GetNextEvent(mUpMask,&event) && (event.when < ticks + DoubleTime)) {
        !          1373:                        set_mark();
        !          1374:                        break;
        !          1375:                }
        !          1376:        } while ((Ticks - ticks) < DoubleTime);
        !          1377:        return(1);
        !          1378: }
        !          1379: 
        !          1380: 
        !          1381: static int ptoxy(p,row,col)    /* convert Point to terminal x,y coordinate */
        !          1382: Point p;
        !          1383: int *row,*col;
        !          1384: {
        !          1385:        *row = (p.v / HEIGHT);
        !          1386:        *col = (p.h / WIDTH );
        !          1387:        if((*row > MAXROW) || (*col > MAXCOL)) return(ERROR);
        !          1388:        return(0);
        !          1389: }
        !          1390: 
        !          1391: /* Event-related routines. The Event loop is CheckEvents(), and is called whenever
        !          1392:    a console read occurs or a call to charp(). During certain activities, such as ask(),
        !          1393:    etc. non-keyboard events are ignored. This is set by the variable Keyonly.
        !          1394:    As an update or activate event generates a call to redisplay(), it is important
        !          1395:    that redisplay() and related routines NOT check for keyboard characters. */
        !          1396: 
        !          1397: /* (ORIGINALLY IN) tevent.c
        !          1398:        event handler for Jove. K Mitchum 12/86 */
        !          1399: 
        !          1400: 
        !          1401: #define SYS_ID 100
        !          1402: #define NOFUNC ((void (*)()) 0)
        !          1403: #define NEVENTS 16
        !          1404: 
        !          1405: extern void doMouse(),dokeyDown(),doUpdate(),doActivate();
        !          1406: static MenuHandle SysMenu;
        !          1407: static void (*eventlist[])() =
        !          1408: {
        !          1409:        NOFUNC, /* nullEvent */
        !          1410:        doMouse,/* mouseDown */
        !          1411:        doMouse, /* mouseUp */
        !          1412:        dokeyDown, /* keyDown */
        !          1413:        NOFUNC, /* keyUp */
        !          1414:        dokeyDown, /* autoKey */
        !          1415:        doUpdate, /* updateEvt */
        !          1416:        NOFUNC, /* diskEvt */
        !          1417:        doActivate, /* activateEvt */
        !          1418:        NOFUNC, /* not  used */
        !          1419:        NOFUNC, /* networkEvt = 10 */
        !          1420:        NOFUNC, /* driverEvt */
        !          1421:        NOFUNC, /* app1Evt */
        !          1422:        NOFUNC, /* app2Evt */
        !          1423:        NOFUNC, /* app3Evt */
        !          1424:        NOFUNC  /* app4Ev */
        !          1425: };
        !          1426: 
        !          1427: 
        !          1428: 
        !          1429: static void CheckEvents()
        !          1430: {
        !          1431:        void SetBufMenu(),
        !          1432:                MarkModes();
        !          1433: 
        !          1434:        static EventRecord theEvent;
        !          1435:        static Point Mousep;
        !          1436:        static long time = 0;
        !          1437: 
        !          1438: 
        !          1439:        static void (*fptr)();
        !          1440: 
        !          1441: 
        !          1442:        if(FrontWindow() == window) {
        !          1443:                GetMouse(&Mousep);
        !          1444:                if(PtInRect(Mousep,&r))
        !          1445:                        SetCursor(*cross);
        !          1446:                else SetCursor(&arrow);
        !          1447:        }
        !          1448: 
        !          1449:        SystemTask();
        !          1450:        if(EventCmd && !Keyonly) return;
        !          1451:        if(Bufchange != 0) SetBufMenu();
        !          1452:        if(Modechange != 0) MarkModes();
        !          1453:        while(GetNextEvent(everyEvent,&theEvent)) {
        !          1454:                if ((theEvent.what < NEVENTS) && (fptr = eventlist[theEvent.what])) {
        !          1455:                        (*fptr)(&theEvent);
        !          1456:                }
        !          1457:                SystemTask();
        !          1458:        }
        !          1459:        if((Ticks - time) > 3600) {
        !          1460:                time = Ticks;
        !          1461:                UpdModLine = YES;
        !          1462:                redisplay();
        !          1463:        }
        !          1464: }
        !          1465: 
        !          1466: static void InitSysMenu()
        !          1467: {
        !          1468:        void InitLocalMenus();
        !          1469: 
        !          1470:        SysMenu = NewMenu(SYS_ID,"\p\24");
        !          1471:        AppendMenu(SysMenu,"\pAbout Jove");
        !          1472:        AddResMenu(SysMenu,'DRVR');
        !          1473:        InsertMenu(SysMenu,0);
        !          1474:        InitLocalMenus();
        !          1475:        DrawMenuBar();
        !          1476: }
        !          1477: 
        !          1478: extern void doWind(),doGoAway(),doSysMenu(),doSysClick(),
        !          1479:         doDrag(), doGrow(), doZoomIn(), doZoomOut();
        !          1480: #define NMEVENTS 9
        !          1481: static void (*mouselist[])() =
        !          1482: {
        !          1483:        NOFUNC, /* inDesk */
        !          1484:        doSysMenu, /* inMenuBar */
        !          1485:        doSysClick, /* inSysWindow */
        !          1486:        doWind, /* inContent */
        !          1487:        doDrag, /* inDrag */
        !          1488:        doGrow, /* inGrow */
        !          1489:        doGoAway, /* inGoAway */
        !          1490:        doZoomIn,       /* inZoomIn */
        !          1491:        doZoomOut       /* inZoomOut */
        !          1492: };
        !          1493: 
        !          1494: 
        !          1495: static void doMouse(event)
        !          1496: EventRecord *event;
        !          1497: {
        !          1498:        WindowPtr theWindow;
        !          1499:        int wpart;
        !          1500:        void (*fptr)();
        !          1501: 
        !          1502:        if(Keyonly) {
        !          1503:                if(event->what == mouseDown) SysBeep(2);
        !          1504:                return;
        !          1505:        }
        !          1506:        wpart = FindWindow(event->where,&theWindow);
        !          1507:        if ((wpart < NMEVENTS) && (fptr = mouselist[wpart])) {
        !          1508:                (*fptr)(event,theWindow);
        !          1509:        }
        !          1510: 
        !          1511: }
        !          1512: 
        !          1513: static void doSysMenu(event,window)
        !          1514: EventRecord *event;
        !          1515: WindowPtr window;
        !          1516: {
        !          1517:        void ProcMenu();
        !          1518: 
        !          1519:        int Menu,Item;
        !          1520:        long result = MenuSelect(event->where);
        !          1521:        Menu = (result >> 16) & 0xffff;
        !          1522:        Item = result & 0xffff;
        !          1523:        if(Item == 0) return;   /* no choice made */
        !          1524: 
        !          1525:        if(Menu == SYS_ID) {                    /* apple menu */
        !          1526:                Str255 Name;
        !          1527:                GrafPtr Port;
        !          1528: 
        !          1529:                if(Item == 1) about_j();
        !          1530:                else {
        !          1531:                        GetItem(SysMenu,Item,Name);
        !          1532:                        GetPort(&Port);
        !          1533:                        OpenDeskAcc(Name);
        !          1534:                        SetPort(Port);
        !          1535:                }
        !          1536:        }
        !          1537:        else ProcMenu(Menu,Item);
        !          1538:        HiliteMenu(0);
        !          1539:        EventCmd = 1;
        !          1540:        menus_on();
        !          1541:        return;
        !          1542: 
        !          1543: }
        !          1544: 
        !          1545: static void doSysClick(event,window)
        !          1546: EventRecord *event;
        !          1547: WindowPtr window;
        !          1548: {
        !          1549:        SystemClick(event,window);
        !          1550: }
        !          1551: 
        !          1552: 
        !          1553: static void doUpdate(event)
        !          1554: EventRecord *event;
        !          1555: {
        !          1556:        WindowPtr theWindow, oldPort;
        !          1557: 
        !          1558:        theWindow = (WindowPtr) event->message;
        !          1559: 
        !          1560:        GetPort(&oldPort);
        !          1561:        SetPort(theWindow);
        !          1562:        BeginUpdate(theWindow);
        !          1563:        p_refresh();
        !          1564:        drawfluff();
        !          1565:        EndUpdate(theWindow);
        !          1566:        SetPort(oldPort);
        !          1567: }
        !          1568: 
        !          1569: static void doActivate(event)
        !          1570: EventRecord *event;
        !          1571: {
        !          1572:        WindowPtr theWindow;
        !          1573:        ControlHandle control;
        !          1574:        int hilite;
        !          1575: 
        !          1576:        theWindow = (WindowPtr) event->message;
        !          1577:        SetPort(theWindow);
        !          1578:        if(event->modifiers & activeFlag) {
        !          1579:                hilite = 0;
        !          1580:        }
        !          1581:        else hilite = 255;
        !          1582:        for(control = (ControlHandle) (((WindowPeek) theWindow)->controlList);
        !          1583:                 (control != 0); control = (*control)->nextControl) {
        !          1584:                        HiliteControl(control,hilite);
        !          1585:        }
        !          1586: }
        !          1587: 
        !          1588: /* Keyboard routines. The Option key was formerly used as a meta key.
        !          1589:    However, to take advantage of the full (non-ASCII) character set,
        !          1590:    this was removed. The corresponding code is ifdeffed O_META. */
        !          1591: 
        !          1592: /* (ORIGINALLY IN) tkey.c
        !          1593:    keyboard routines for Macintosh. K Mitchum 12/86 */
        !          1594: 
        !          1595: extern jmp_buf auxjmp;
        !          1596: 
        !          1597: static nchars = 0;
        !          1598: static char charbuf[MCHARS];
        !          1599: /* the following kludges a meta key out of the option key by
        !          1600: sending an escape sequence back to the dispatch routines. this is
        !          1601: not elegant but it works, and doesn't alter escape sequences for
        !          1602: those that prefer them. to remap the control or meta keys,
        !          1603: see mackeys.h. */
        !          1604: 
        !          1605: static void dokeyDown(event)
        !          1606: EventRecord *event;
        !          1607: {
        !          1608:        unsigned mods;
        !          1609:        register c;
        !          1610:        static int cptr = 0;
        !          1611: 
        !          1612:        if(MCHARS - nchars < 2) return;
        !          1613: 
        !          1614:        c  = (char)((event->message)&(charCodeMask));
        !          1615: 
        !          1616:        mods = event->modifiers;
        !          1617: 
        !          1618: #ifdef O_META
        !          1619:        if (mods & (optionKey | cmdKey | controlKey)) {
        !          1620: #else
        !          1621:        if (mods & (cmdKey | controlKey)) {
        !          1622: #endif
        !          1623: /*             if(mods & shiftKey)
        !          1624:                        c  = sh_keycodes[(((event->message)&(keyCodeMask))>>8)];
        !          1625:                else
        !          1626:                        c  = nsh_keycodes[(((event->message)&(keyCodeMask))>>8)];*/
        !          1627: #ifdef O_META
        !          1628:                if(mods & optionKey) {          /* make escape sequence */
        !          1629:                        if(mods & cmdKey) c &= 0x1f;
        !          1630:                        charbuf[cptr++] = '\033';
        !          1631:                        cptr &= NMASK;          /* zero if necessary */
        !          1632:                        nchars++;
        !          1633:                }
        !          1634:                else
        !          1635: #endif
        !          1636:                {       /* command key (control key) */
        !          1637:                        if((c == '2') || (c == '\\') || (c == ' ')) c = 0;      /* so we have a null char */
        !          1638:                        if(c != '`') c &= 0x1f;         /* make a control char */
        !          1639:                }
        !          1640:        }
        !          1641:        else {
        !          1642:                if(c == '`') c = '\033';        /* for those used to escapes */
        !          1643:        }
        !          1644: 
        !          1645:        charbuf[cptr++] = c;
        !          1646:        cptr &= NMASK;
        !          1647:        nchars++;
        !          1648: }
        !          1649: 
        !          1650: static int rawgetc()
        !          1651: {
        !          1652:        static int cptr = 0;
        !          1653:        register c;
        !          1654: 
        !          1655:        if(EventCmd) longjmp(auxjmp,0);
        !          1656:        while(nchars <= 0) {
        !          1657:                nchars = 0;
        !          1658:                if(EventCmd) longjmp(auxjmp,0);
        !          1659:                CheckEvents();  /* ugh! WAIT for a character */
        !          1660:        }
        !          1661:        nchars--;
        !          1662:        c = charbuf[cptr++];
        !          1663:        cptr &= NMASK;          /* zero if necessary */
        !          1664:        return(c);
        !          1665: }
        !          1666: 
        !          1667: int rawchkc()
        !          1668: {
        !          1669:        if(EventCmd) longjmp(auxjmp,0);
        !          1670:        if(nchars == 0) CheckEvents();  /* this should NOT be necessary! */
        !          1671:        return(nchars > 0);
        !          1672: }
        !          1673: 
        !          1674: /* Routines for calling the standard file dialogs, when macify is ON. If the user
        !          1675:    changes the directory using the file dialogs, Jove's notion of the current directory
        !          1676:    is updated. */
        !          1677: 
        !          1678: 
        !          1679: /* (ORIGINALLY IN) tmacf.c. K. Mitchum 12/86.
        !          1680:    Macify routines for jove. */
        !          1681: 
        !          1682: int CurrentVol;                        /* see tfile.c */
        !          1683: 
        !          1684: 
        !          1685: #define TYPES  (-1)
        !          1686: 
        !          1687: static Point px = {100,100};
        !          1688: static char pmess[] = "\pSave file as: ";
        !          1689: 
        !          1690: static pascal Boolean Ffilter(p)
        !          1691: FileParam *p;
        !          1692: {
        !          1693:        if(p->ioFlFndrInfo.fdType == 'APPL') return TRUE;
        !          1694:        PtoCstr((char *) p->ioNamePtr);
        !          1695:        if(strcmp(p->ioNamePtr,d_tempfile) == 0) {
        !          1696:                CtoPstr((char *) p->ioNamePtr);
        !          1697:                return TRUE;
        !          1698:        }
        !          1699:        CtoPstr((char *) p->ioNamePtr);
        !          1700:        return FALSE;
        !          1701: }
        !          1702: 
        !          1703: static void check_dir()
        !          1704: {
        !          1705:        if(cur_vol != 0 - SFSaveDisk || cur_dir != CurDirStore) {
        !          1706:                setdir(0 - SFSaveDisk, CurDirStore);
        !          1707:                UpdModLine = YES;       /* make sure jove knows the change */
        !          1708:                Modechange++;
        !          1709:                setCWD(getwd());
        !          1710:        }
        !          1711: }
        !          1712: 
        !          1713: char *gfile(namebuf)   /* return a filename to get */
        !          1714: char *namebuf;
        !          1715: {
        !          1716:        SFReply frec;
        !          1717:        char ans[FILESIZE];
        !          1718: 
        !          1719:        SFSaveDisk = 0 - cur_vol;       /* in case a Desk Accessory changed them */
        !          1720:        CurDirStore = cur_dir;
        !          1721:        SFGetFile(px,0L,Ffilter,TYPES,0L,0L,&frec);
        !          1722:        check_dir();    /* see if any change, set if so */
        !          1723:        if(frec.good) {
        !          1724:                EventRecord theEvent;
        !          1725:                while(GetNextEvent(updateMask,&theEvent) == 0);
        !          1726:                doUpdate(&theEvent);
        !          1727:                PtoCstr((char *)frec.fName);
        !          1728:                strcpy(ans,frec.fName);
        !          1729:                CtoPstr((char *)frec.fName);
        !          1730:                PathParse(ans,namebuf);
        !          1731:                return(namebuf);
        !          1732:        }
        !          1733:        return(char *) 0;
        !          1734: }
        !          1735: 
        !          1736: char *pfile(namebuf)
        !          1737: char *namebuf;
        !          1738: {
        !          1739:        SFReply frec;
        !          1740:        char *t, *nm;
        !          1741:        SFSaveDisk = 0 - cur_vol;       /* in case a Desk Accessory changed them */
        !          1742:        CurDirStore = cur_dir;
        !          1743:        strncpy(namebuf,filename(curbuf),63);
        !          1744:        nm = cvt_fnm(namebuf);
        !          1745:        CtoPstr(nm);
        !          1746:        SFPutFile(px,pmess,nm,0L,&frec);
        !          1747:        check_dir();    /* see if any change, set if so */
        !          1748:        if(frec.good) {
        !          1749:                EventRecord theEvent;
        !          1750:                while(GetNextEvent(updateMask,&theEvent) == 0);
        !          1751:                doUpdate(&theEvent);
        !          1752:                t = (char *)frec.fName;
        !          1753:                PtoCstr((char *)frec.fName);
        !          1754:                while(*t == ':') t++;   /* convert to unix style */
        !          1755:                nm = t;
        !          1756:                while(*nm) {
        !          1757:                        if(*nm == ':') *nm = '/';
        !          1758:                        nm++;
        !          1759:                }
        !          1760:                PathParse(t,namebuf);
        !          1761:                return(namebuf);
        !          1762:        }
        !          1763:        return(char *) 0;
        !          1764: }
        !          1765: 
        !          1766: 
        !          1767: /* getArgs() returns an argument list based on documents clicked on by the user. */
        !          1768: 
        !          1769: int getArgs(avp)
        !          1770: char ***avp;
        !          1771: {
        !          1772:        int argc, nargs, type, old_vol;
        !          1773:        long old_dir;
        !          1774:        char **argv;
        !          1775:        char *pathname;
        !          1776:        AppFile p;
        !          1777:        WDPBRec d;
        !          1778: 
        !          1779:        old_vol = cur_vol;
        !          1780:        old_dir = cur_dir;
        !          1781: 
        !          1782:        CountAppFiles(&type,&nargs);
        !          1783:        if(nargs > 0) { /* files to open... */
        !          1784:                argv = (char **) malloc((nargs + 2) * sizeof(char *));
        !          1785:                for(argc = 1; argc <= nargs; argc++) {
        !          1786:                        GetAppFiles(argc,&p);
        !          1787:                        if(type == 0) {
        !          1788:                                PtoCstr((char *)p.fName);
        !          1789:                                d.ioCompletion = 0;
        !          1790:                                d.ioNamePtr = 0;
        !          1791:                                d.ioVRefNum = p.vRefNum;
        !          1792:                                d.ioWDIndex = 0;
        !          1793:                                PBGetWDInfo(&d,0);
        !          1794:                                cur_vol = d.ioWDVRefNum;
        !          1795:                                cur_dir = d.ioWDDirID;
        !          1796:                                pathname = getwd();
        !          1797:                                argv[argc] = malloc(strlen((char *)p.fName) + strlen(pathname) + 2);
        !          1798:                                strcpy(argv[argc],pathname);
        !          1799:                                strcat(argv[argc],"/");
        !          1800:                                strcat(argv[argc],(char *)p.fName);
        !          1801:                        }
        !          1802:                        ClrAppFiles(argc);
        !          1803:                }
        !          1804:                if(type != 0) argc = 1;
        !          1805:        }
        !          1806:        else {
        !          1807:                argv = (char **) malloc(2 * sizeof(char*));
        !          1808:                argc = 1;
        !          1809:        }
        !          1810:        argv[0] = "jove";
        !          1811: 
        !          1812:        argv[argc] = 0;
        !          1813:        *avp = argv;
        !          1814:        cur_dir = old_dir;
        !          1815:        cur_vol = old_vol;
        !          1816:        return(argc);
        !          1817: }
        !          1818: 
        !          1819: /* Limited version of getenv() */
        !          1820: 
        !          1821: char *getenv(item)
        !          1822: char *item;
        !          1823: {
        !          1824:        char *ret = 0, *str = 0;
        !          1825: 
        !          1826:        if(strcmp(item,"CWD") == 0) str = getwd();
        !          1827:        if(strcmp(item,"HOME") == 0) str = gethome();
        !          1828:        if(str) {
        !          1829:                ret = malloc(strlen(str) + 1);
        !          1830:                strcpy(ret,str);
        !          1831:        }
        !          1832:        return(ret);
        !          1833: }
        !          1834: 
        !          1835: char *mktemp(name)
        !          1836: char *name;
        !          1837: {
        !          1838:        return name;
        !          1839: }
        !          1840: 
        !          1841: 
        !          1842: /* Menu routines. The menus items are set up in a similar manner as keys, and
        !          1843:    are bound prior to runtime. See menumaps.txt, which must be run through setmaps.
        !          1844:    Unlike keys, menu items may be bound to variables, and to buffers. Buffer binding
        !          1845:    is only done at runtime. */
        !          1846: 
        !          1847: static void InitLocalMenus()
        !          1848: {
        !          1849:        void InitMenu(),
        !          1850:                make_edits();
        !          1851: 
        !          1852:        int i;
        !          1853:        for(i = 0; i < NMENUS; i++) {
        !          1854:                InitMenu(&Menus[i]);
        !          1855:                if(i == 0) make_edits(Menus[i].menu_id + 1);
        !          1856:        }
        !          1857: }
        !          1858: 
        !          1859: static void InitMenu(M)
        !          1860: struct menu *M;
        !          1861: {
        !          1862:        int i;
        !          1863:        data_obj *d;
        !          1864:        char *name;
        !          1865: 
        !          1866:        if(M->menu_id == 0) return;
        !          1867:        M->Mn = NewMenu(M->menu_id,CtoPstr(M->Name));
        !          1868:        PtoCstr(M->Name);
        !          1869: 
        !          1870:        for(i = 0; i < NMENUITEMS; i++) {
        !          1871:                d = (M->m[i]);
        !          1872:                if(d == 0) break;       /* last item... */
        !          1873:                switch (d->Type & TYPEMASK) {
        !          1874:                        case (STRING) :
        !          1875:                                AppendMenu(M->Mn,CtoPstr(d->Name));
        !          1876:                                PtoCstr(d->Name);
        !          1877:                                break;
        !          1878:                        case (VARIABLE) :
        !          1879:                                SetItemMark(M->Mn,i + 1, 0x12);
        !          1880:                        case (FUNCTION) :
        !          1881:                                CtoPstr(name = ((data_obj *) d)->Name);
        !          1882:                                AppendMenu(M->Mn,name);
        !          1883:                                PtoCstr(name);
        !          1884:                }
        !          1885:        }
        !          1886:        InsertMenu(M->Mn,0);
        !          1887: }
        !          1888: 
        !          1889: static void ProcMenu(menuno,itemno)
        !          1890: int menuno,itemno;
        !          1891: {
        !          1892:        void MacSetVar();
        !          1893: 
        !          1894:        int i;
        !          1895:        data_obj *d;
        !          1896: 
        !          1897:        for(i = 0; i < NMENUS && Menus[i].menu_id != menuno; i++);
        !          1898:        if(i < NMENUS) {        /* found the menu */
        !          1899:                itemno--;
        !          1900:                d = Menus[i].m[itemno];
        !          1901:                switch(d->Type & TYPEMASK) {
        !          1902:                        case FUNCTION :
        !          1903:                                ExecCmd((data_obj *) d);
        !          1904:                                break;
        !          1905:                        case BUFFER :
        !          1906:                                        SetABuf(curbuf);
        !          1907:                                        tiewind(curwind,(Buffer *) d);
        !          1908:                                        SetBuf((Buffer *) d);
        !          1909:                                break;
        !          1910:                        case VARIABLE :
        !          1911:                                        MacSetVar((struct variable *) d,i,itemno);
        !          1912:                                break;
        !          1913:                        default :
        !          1914:                                break;
        !          1915:                }
        !          1916: 
        !          1917:        }
        !          1918: }
        !          1919: 
        !          1920: 
        !          1921: 
        !          1922: 
        !          1923: 
        !          1924: 
        !          1925: static void make_edits(menu)   /* add dummy edit menu */
        !          1926: int menu;
        !          1927: {
        !          1928:        MenuHandle M;
        !          1929:        int item;
        !          1930:        char *fname;
        !          1931: 
        !          1932:        M = NewMenu((menu),"\pEdit");
        !          1933:        AppendMenu(M,"\pUndo/Z;(-;Cut/X;Copy/C;Paste/V;Clear;Select All;(-;Show Clipboard");
        !          1934:        InsertMenu(M,0);
        !          1935:        DisableItem(M,0);
        !          1936: }
        !          1937: 
        !          1938: void menus_off()
        !          1939: {
        !          1940:        int i;
        !          1941:        if(Keyonly || EventCmd) return;
        !          1942:        
        !          1943: #ifdef MENU_DISABLE            /* NOBODY likes this, but it's here if you want it... */
        !          1944:        DisableItem(SysMenu,0);
        !          1945:        for(i = 0; i < NMENUS; i++)
        !          1946:                if(Menus[i].Mn) DisableItem(Menus[i].Mn,0);
        !          1947:        DrawMenuBar();
        !          1948: #endif
        !          1949:        Keyonly = 1;
        !          1950: }
        !          1951: 
        !          1952: void menus_on()
        !          1953: {
        !          1954:        int i;
        !          1955: 
        !          1956:        if(Keyonly == 0) return;
        !          1957: #ifdef MENU_DISABLE
        !          1958:        EnableItem(SysMenu,0);
        !          1959:        for(i = 0; i < NMENUS; i++)
        !          1960:                if(Menus[i].Mn) EnableItem(Menus[i].Mn,0);
        !          1961:        DrawMenuBar();
        !          1962: #endif
        !          1963:        Keyonly = 0;
        !          1964: }
        !          1965: 
        !          1966: static char *BufMPrint(b,i)
        !          1967: Buffer *b;
        !          1968: {
        !          1969:        char *p;
        !          1970:        char *nm = filename(b);
        !          1971:        char t[35];
        !          1972: 
        !          1973:        if(strlen(nm) > 30) {
        !          1974:                strcpy(t,"...");
        !          1975:                strcat(t,nm + strlen(nm) - 30);
        !          1976:        }
        !          1977:        else strcpy(t,nm);
        !          1978:        nm = t;
        !          1979:        while(*nm) {
        !          1980:                switch(*nm) {   /* ugh... these are metacharacter for Menus */
        !          1981:                        case '/' : *nm = ':'; break;
        !          1982:                        case '^' :
        !          1983:                        case '!' :
        !          1984:                        case '<' :
        !          1985:                        case '(' :
        !          1986:                        case ';' : *nm = '.'; break;    /* that will confuse everybody */
        !          1987:                }
        !          1988:                nm++;
        !          1989:        }
        !          1990:        p = sprint("%-2d %-11s \"%-s\"",i,b->b_name,t);
        !          1991:        return(p);
        !          1992: }
        !          1993: 
        !          1994: static void SetBufMenu()
        !          1995: {
        !          1996:        register Buffer *b;
        !          1997:        data_obj *d;
        !          1998:        int i,j,stop;
        !          1999:        struct menu *M;
        !          2000: 
        !          2001:        Bufchange = 0;
        !          2002:        for(i = 0; i < NMENUS && strcmp(Menus[i].Name,"Buffer"); i++);
        !          2003:        if(i < NMENUS) {
        !          2004:                M = &Menus[i];
        !          2005:                for(j = 0; j < NMENUITEMS && (d = Menus[i].m[j]) && (d->Type & TYPEMASK) != BUFFER; j++);
        !          2006:                if(j < NMENUITEMS) {
        !          2007:                        for(i = j, b = world; i < NMENUITEMS && b != 0; i++, b = b->b_next) {
        !          2008: 
        !          2009:                                if(M->m[i] == 0)
        !          2010:                                        AppendMenu(M->Mn,CtoPstr(BufMPrint(b,i-j+1)));  /* add the item */
        !          2011:                                else
        !          2012:                                        SetItem(M->Mn,i + 1,CtoPstr(BufMPrint(b,i-j+1)));       /* or change it */
        !          2013:                                M->m[i] = (data_obj *) b;
        !          2014:                        }
        !          2015:                        stop = i;
        !          2016:                          /* out of buffers? */
        !          2017:                        for(;i < NMENUITEMS && M->m[i];i++) {
        !          2018:                                DelMenuItem(M->Mn,stop + 1);    /* take off last item */
        !          2019:                                M->m[i] = 0;
        !          2020:                        }
        !          2021:                }
        !          2022:        }
        !          2023:        return;
        !          2024: }
        !          2025: 
        !          2026: static void MacSetVar(vp,mnu,itm)      /* Set a variable from the menu */
        !          2027: struct variable *vp;   /* Liberally taken from SetVar() in extend.c */
        !          2028: int mnu,itm;
        !          2029: {
        !          2030:        void MarkVar();
        !          2031: 
        !          2032:        char *prompt;
        !          2033: 
        !          2034:        prompt = sprint("Set %s: ", vp->Name);
        !          2035:        switch (vp->v_flags & V_TYPEMASK) {
        !          2036:        case V_BASE10:
        !          2037:        case V_BASE8:
        !          2038:            {
        !          2039:                int     value;
        !          2040: 
        !          2041:                value = ask_int(prompt, ((vp->v_flags & V_TYPEMASK) == V_BASE10)
        !          2042:                                          ? 10 : 8);
        !          2043:                *(vp->v_value) = value;
        !          2044:                break;
        !          2045:            }
        !          2046:        case V_BOOL:    /* toggle the value */
        !          2047:                *(vp->v_value) = (*vp->v_value == ON ? OFF : ON);
        !          2048:                MarkVar(vp,mnu,itm);
        !          2049:                break;
        !          2050:        case V_FILENAME:
        !          2051:        case V_STRING:
        !          2052:            {
        !          2053:                char    *str;
        !          2054: 
        !          2055:                /* Do_ask() so you can set string to "" if you so desire. */
        !          2056:                str = do_ask("\r\n", (int (*) proto((int))) 0, (char *) vp->v_value,
        !          2057:                        prompt);
        !          2058:                if (str == 0)
        !          2059:                        str = NullStr;
        !          2060:                strcpy((char *) vp->v_value, str);
        !          2061:                /* ... and hope there is enough room. */
        !          2062:                break;
        !          2063:            }
        !          2064:        case V_CHAR:
        !          2065:                f_mess(prompt);
        !          2066:                *(vp->v_value) = addgetc();
        !          2067:                break;
        !          2068:        }
        !          2069: 
        !          2070:        if (vp->v_flags & V_MODELINE)
        !          2071:                UpdModLine = YES;
        !          2072:        if (vp->v_flags & V_CLRSCREEN) ClAndRedraw();
        !          2073:        if (vp->v_flags & V_TTY_RESET) tty_reset(); /* probably none on a Mac */
        !          2074:        return;
        !          2075: }
        !          2076: 
        !          2077: static void MarkModes()
        !          2078: {
        !          2079:        int mnu,itm,checked;
        !          2080:        data_obj *d;
        !          2081: 
        !          2082:        Modechange = 0;
        !          2083:        for(mnu = 0; mnu < NMENUS; mnu++)
        !          2084:                for(itm = 0; itm < NMENUITEMS; itm++) {
        !          2085:                        if((d = Menus[mnu].m[itm]) == 0) break;
        !          2086:                        if((d->Type & (MAJOR_MODE | MINOR_MODE)) ||
        !          2087:                                 ((d->Type & TYPEMASK) == BUFFER)){
        !          2088:                                if(d->Type & (MAJOR_MODE))
        !          2089:                                        checked = (curbuf->b_major == (d->Type >> 8)) ? 1 : 0;
        !          2090:                                else if(d->Type & (MINOR_MODE))
        !          2091:                                        checked = (curbuf->b_minor & (d->Type >> 8)) ? 1 : 0;
        !          2092:                                else
        !          2093:                                        checked = (d == (data_obj *) curbuf) ? 1 : 0;
        !          2094:                                CheckItem(Menus[mnu].Mn, itm + 1, checked);
        !          2095:                        }
        !          2096:                }
        !          2097: }
        !          2098: 
        !          2099: void MarkVar(vp,mnu,itm)       /* mark a boolean menu item */
        !          2100: struct variable *vp;
        !          2101: int mnu,itm;
        !          2102: {
        !          2103:        int checked;
        !          2104:        if(mnu == -1) {         /* we don't know the item... slow */
        !          2105:                int found;
        !          2106:                for(mnu = 0, found = 0; (mnu < NMENUS) && !found; mnu++) {
        !          2107:                        for(itm = 0; (itm < NMENUITEMS); itm++)
        !          2108:                                if((struct variable *) (Menus[mnu].m[itm]) == vp) {
        !          2109:                                        found++;
        !          2110:                                        break;
        !          2111:                                }
        !          2112:                        if(found) break;
        !          2113:                }
        !          2114:                if(!found) return;
        !          2115:        }
        !          2116:        checked = (*(vp->v_value) == ON);
        !          2117:        CheckItem(Menus[mnu].Mn, itm + 1, checked);
        !          2118: }
        !          2119: 
        !          2120: static void MarkAllVar()       /* slow, but only do it once */
        !          2121: {
        !          2122:        int mnu,itm;
        !          2123:        data_obj *d;
        !          2124:        for(mnu = 0; mnu < NMENUS; mnu++)
        !          2125:                for(itm = 0; itm < NMENUITEMS; itm++) {
        !          2126:                        if((d = Menus[mnu].m[itm]) == 0) break;
        !          2127:                        if((d->Type & TYPEMASK) == VARIABLE)
        !          2128:                                MarkVar((struct variable *)Menus[mnu].m[itm],mnu,itm);
        !          2129:                }
        !          2130: }
        !          2131: 
        !          2132: 
        !          2133: /* Screen routines and driver. The Macinitosh Text Edit routines are not utilized,
        !          2134:    as they are slow and cumbersome for a terminal emulator. Instead, direct QuickDraw
        !          2135:    calls are used. The fastest output is obtained writing a line at a time, rather
        !          2136:    than on a character basis, so the major output routine is writechr(), which takes
        !          2137:    a pascal-style string as an argument. See bufputc() in screen.c. */
        !          2138: 
        !          2139: void Placur(line,col)
        !          2140: int line, col;
        !          2141: {
        !          2142:        CapCol = col;
        !          2143:        CapLine = line;
        !          2144:        putcurs(line,col,ON);
        !          2145: }
        !          2146: 
        !          2147: void NPlacur(line,col)
        !          2148: int line, col;
        !          2149: {
        !          2150:        CapCol = col;
        !          2151:        CapLine = line;
        !          2152:        putcurs(line,col,OFF);
        !          2153: }
        !          2154: 
        !          2155: void i_lines(top, bottom, num)
        !          2156: int top, bottom, num;
        !          2157: {
        !          2158:        Placur(bottom - num + 1, 0);
        !          2159:        dellines(num,bottom);
        !          2160:        Placur(top, 0);
        !          2161:        inslines(num,bottom);
        !          2162: }
        !          2163: 
        !          2164: void d_lines(top, bottom, num)
        !          2165: int top, bottom, num;
        !          2166: {
        !          2167:        Placur(top, 0);
        !          2168:        dellines(num,bottom);
        !          2169:        Placur(bottom + 1 - num, 0);
        !          2170:        inslines(num,bottom);
        !          2171: }
        !          2172: 
        !          2173: /* (ORIGINALLY IN) tn.c   */
        !          2174: /* window driver for MacIntosh using windows. */
        !          2175: /* K. Mitchum 9/86 */
        !          2176: 
        !          2177: 
        !          2178: /*#define VARFONT*/
        !          2179: #ifdef VARFONT
        !          2180: static height,width,theight,twidth,descent;
        !          2181: #else
        !          2182: #define height HEIGHT
        !          2183: #define width WIDTH
        !          2184: #define theight THEIGHT
        !          2185: #define twidth TWIDTH
        !          2186: #define descent DESCENT
        !          2187: #endif
        !          2188: 
        !          2189: static trow,tcol, insert, tattr, cursor;
        !          2190: static Rect cursor_rect;
        !          2191: static char *p_scr, *p_curs;   /* physical screen and cursor */
        !          2192: static int p_size;
        !          2193: 
        !          2194: static Rect  vRect;
        !          2195: static WindowRecord myWindowRec;
        !          2196: 
        !          2197: #define active() SetPort(theScreen)
        !          2198: #define maxadjust(r) OffsetRect((r),0,2);
        !          2199: 
        !          2200: char *conv_p_curs(row,col) 
        !          2201: {
        !          2202:        return(p_scr + (row * (CO)) + col);
        !          2203: }
        !          2204: 
        !          2205: static void INSmode(new)
        !          2206: int new;
        !          2207: {
        !          2208:        insert = new;
        !          2209: }
        !          2210: 
        !          2211: static void HLmode(new)
        !          2212: int new;
        !          2213: {
        !          2214:        if(new) tattr = 1;
        !          2215:        else tattr = 0;
        !          2216: }
        !          2217: void SO_on()
        !          2218: {
        !          2219:        HLmode(1);
        !          2220: }
        !          2221: 
        !          2222: void SO_off()
        !          2223: {
        !          2224:        HLmode(0);
        !          2225: }
        !          2226: 
        !          2227: 
        !          2228: static void tn_init()
        !          2229: {
        !          2230:        void INSmode(),
        !          2231:        init_slate();
        !          2232: 
        !          2233:        HLmode(0);
        !          2234:        INSmode(0);
        !          2235:        init_slate();
        !          2236:        ShowPen();
        !          2237: }
        !          2238: 
        !          2239: void clr_page()        /* clear and home function */
        !          2240: {
        !          2241:        Rect r;
        !          2242: 
        !          2243:        setmem(p_scr,p_size,' ');
        !          2244:        active();
        !          2245:        SetRect(&r, 0,0,WINDWIDTH,WINDHEIGHT);
        !          2246:        EraseRect(&r);
        !          2247:        cursor = OFF;
        !          2248:        putcurs(0,0);
        !          2249:        drawfluff();
        !          2250: }
        !          2251: 
        !          2252: static void putcurs(row,col,vis)
        !          2253: unsigned row, col, vis;
        !          2254: {
        !          2255:        active();
        !          2256:        curset(OFF);
        !          2257:        trow = row;
        !          2258:        tcol = col;
        !          2259:        curset(vis);
        !          2260: }
        !          2261: 
        !          2262: static void curset(desired)
        !          2263: {
        !          2264:        p_curs = conv_p_curs(trow,tcol);
        !          2265:        if(trow == MAXROW)
        !          2266:                MoveTo(tcol * width, (trow  +1) * height + 2 -descent );
        !          2267:        else
        !          2268:                MoveTo(tcol * width, (trow  +1) * height - descent);
        !          2269: 
        !          2270:        DrawChar(*p_curs);
        !          2271: 
        !          2272:        if(desired == ON) {
        !          2273:                SetRect(&cursor_rect, tcol * width, (trow) * height , (tcol + 1) * width - 1, (trow +1) * height -1);
        !          2274:                if(trow == MAXROW) maxadjust(&cursor_rect);
        !          2275:                InvertRect(&cursor_rect);
        !          2276:        }
        !          2277:        if(trow == MAXROW)
        !          2278:                MoveTo(tcol * width, (trow  +1) * height + 2 -descent );
        !          2279:        else
        !          2280:                MoveTo(tcol * width, (trow  +1) * height - descent);
        !          2281: }
        !          2282: 
        !          2283: 
        !          2284: void putp(p)                   /* put one character, advance cursor */
        !          2285: int p;
        !          2286: {
        !          2287:        static Rect r;
        !          2288:        static RgnHandle updateRgn;
        !          2289: 
        !          2290:        active();
        !          2291:        curset(OFF);
        !          2292:        if(insert) {
        !          2293:                updateRgn = NewRgn();
        !          2294:                SetRect(&r, tcol * width, trow * height, WINDWIDTH, (trow +1) * height -1);
        !          2295:                if(trow == MAXROW) maxadjust(&r);
        !          2296:                ScrollRect(&r, width, 0, updateRgn);
        !          2297:                DisposeRgn(updateRgn);
        !          2298:        }
        !          2299:        if(p == '0') p = 0xAF;  /* slashed zero */
        !          2300:        if(insert) BlockMove(p_curs, p_curs + 1, (long) (MAXCOL - tcol));
        !          2301:        *p_curs = (char) p;
        !          2302:        DrawChar(p);
        !          2303:        if(tcol >= MAXCOL) putcurs(trow,MAXCOL);
        !          2304:        else putcurs(trow,tcol +1);
        !          2305: }
        !          2306: 
        !          2307: void clr_eoln()
        !          2308: {
        !          2309:                static Rect r;
        !          2310: 
        !          2311:                active();
        !          2312:                cursor = OFF;
        !          2313:                SetRect(&r, tcol * width, trow * height, WINDWIDTH, (trow +1) * height);
        !          2314:                if(trow == MAXROW) maxadjust(&r);
        !          2315:                EraseRect(&r);
        !          2316:                setmem(p_curs,CO - tcol, ' ');
        !          2317:                curset(ON);
        !          2318: }
        !          2319: 
        !          2320: static void delchars()
        !          2321: {
        !          2322:                static Rect r;
        !          2323:                static RgnHandle updateRgn;
        !          2324: 
        !          2325:        active();
        !          2326:        curset(OFF);
        !          2327:        updateRgn = NewRgn();
        !          2328:        SetRect(&r, tcol * width, trow * height, twidth - width, (trow +1) * height);
        !          2329:        if(trow == MAXROW) maxadjust(&r);
        !          2330:        ScrollRect(&r, 0 - width, 0, updateRgn);
        !          2331:        DisposeRgn(updateRgn);
        !          2332:        BlockMove(p_curs + 1, p_curs, (long) (MAXCOL - tcol));
        !          2333:        *(conv_p_curs(trow,MAXCOL)) = ' ';
        !          2334:        curset(ON);
        !          2335: }
        !          2336: 
        !          2337: static void dellines(n,bot)
        !          2338: int n,bot;
        !          2339: {
        !          2340:        Rect r;
        !          2341:        RgnHandle updateRgn;
        !          2342:        long len;
        !          2343: 
        !          2344:        updateRgn = NewRgn();
        !          2345:        active();
        !          2346:        curset(OFF);
        !          2347:        SetRect(&r, 0, ((trow) * height), WINDWIDTH, ((bot + 1) * height));
        !          2348:        ScrollRect(&r, 0, 0 - (n * height), updateRgn);
        !          2349:        DisposeRgn(updateRgn);
        !          2350:        len = ((bot - trow - n + 1) * CO);
        !          2351:        BlockMove(conv_p_curs((trow + n),0), conv_p_curs(trow,0), len);
        !          2352:        setmem(conv_p_curs((bot - n + 1),0),(n * CO),' ');
        !          2353:        putcurs(trow,0);
        !          2354: }
        !          2355: 
        !          2356: static void inslines(n,bot)
        !          2357: int n,bot;
        !          2358: {
        !          2359:        Rect r;
        !          2360:        RgnHandle updateRgn;
        !          2361:        long len;
        !          2362: 
        !          2363:        updateRgn = NewRgn();
        !          2364:        active();
        !          2365:        curset(OFF);
        !          2366:        SetRect(&r, 0, trow * height, WINDWIDTH, (bot +1) * height);
        !          2367:        ScrollRect(&r, 0, (n * height), updateRgn);
        !          2368:        DisposeRgn(updateRgn);
        !          2369:        len = ((bot - trow - n +1) * CO);
        !          2370:        BlockMove(conv_p_curs(trow,0), conv_p_curs((trow + n),0), len);
        !          2371:        setmem(conv_p_curs(trow,0),(n * CO),' ');
        !          2372:        putcurs(trow,0);
        !          2373: }
        !          2374: 
        !          2375: void writechr(start)
        !          2376: char *start;   /* actually, a Str255 type string */
        !          2377: {
        !          2378:        static Rect r;
        !          2379:        static RgnHandle updateRgn;
        !          2380:        register len;
        !          2381:        register char save;
        !          2382: 
        !          2383:        len = (int) start[0] & 0xff;            /* adjusted 6/86 K. M. in td.c*/
        !          2384: 
        !          2385:        active();
        !          2386:        curset(OFF);
        !          2387:        if(insert) {
        !          2388:                updateRgn = NewRgn();
        !          2389:                SetRect(&r, tcol * width, trow * height, twidth - width * len, (trow +1) * height -1);
        !          2390:                if(trow == MAXROW) maxadjust(&r);
        !          2391:                ScrollRect(&r, width * len, 0, updateRgn);
        !          2392:                DisposeRgn(updateRgn);
        !          2393:        }
        !          2394:        DrawString(start);
        !          2395:        if(insert) BlockMove(p_curs,p_curs + len, (long) (CO - tcol - len));
        !          2396:        strncpy(p_curs,start + 1,len);
        !          2397:        if(tcol >= MAXCOL) putcurs(trow,MAXCOL);
        !          2398:        else putcurs(trow,tcol +len);
        !          2399: }
        !          2400: 
        !          2401: static Rect myBoundsRect;
        !          2402: static void init_slate()
        !          2403: {
        !          2404:        FontInfo f;
        !          2405: 
        !          2406:        char *Name = "Jove ";
        !          2407:        char *Title;
        !          2408: 
        !          2409:        InitGraf(&thePort);
        !          2410:        InitWindows();
        !          2411:        InitCursor();
        !          2412:        InitFonts ();
        !          2413:        InitMenus ();
        !          2414:        InitDialogs ((ProcPtr) 0);              /* no restart proc */
        !          2415: 
        !          2416:        /* figure limiting rectangle for window moves */
        !          2417:        SetRect(&LimitRect,
        !          2418:                screenBits.bounds.left + 3,
        !          2419:                screenBits.bounds.top + 20,
        !          2420:                screenBits.bounds.right - 3,
        !          2421:                screenBits.bounds.bottom -3);
        !          2422: 
        !          2423:        Set_std();
        !          2424:        SetBounds();
        !          2425: 
        !          2426:        /* initialize char array for updates */
        !          2427:        p_scr = emalloc(p_size = wc_std.w_cols * wc_std.w_rows);        /* only once */
        !          2428:        p_curs = p_scr;
        !          2429:        
        !          2430:        Title = sprint("%s%s",Name,version);
        !          2431:        theScreen = NewWindow(&myWindowRec, &myBoundsRect,CtoPstr(Title),
        !          2432:                1,8,(WindowPtr) -1, 1, (long) 0);
        !          2433: 
        !          2434:        /* figure an initial window configuration and adjust it */
        !          2435:        wc = &wc_std;
        !          2436:        wc_user = wc_std;       /* initially, only one configuration to toggle */
        !          2437:        user_state(theScreen) = std_state(theScreen);
        !          2438:        SetPort(theScreen);
        !          2439: 
        !          2440:        (theScreen)->txFont = FONT;
        !          2441:        (theScreen)->txSize = TEXTSIZE;
        !          2442: 
        !          2443: #ifdef VARFONT
        !          2444:        GetFontInfo(&f);
        !          2445:                height = f.ascent+f.descent+f.leading;
        !          2446:                width = f.widMax;
        !          2447:                twidth = width * wc->w_cols;
        !          2448:                theight = height * wc->w_rows;
        !          2449:                descent = f.descent;
        !          2450: #endif
        !          2451: 
        !          2452:        theScreen->txMode = patCopy;
        !          2453:        theScreen->pnMode = patCopy;
        !          2454:        PenNormal();
        !          2455:        cursor = OFF;
        !          2456: }
        !          2457: 
        !          2458: p_refresh()
        !          2459: {
        !          2460:        int lineno;
        !          2461:        char *curs, *buf;
        !          2462: 
        !          2463:        buf = malloc(CO + 1);
        !          2464:        for(lineno = 0; lineno < LI; lineno++) {
        !          2465:                curs = conv_p_curs(lineno,0);
        !          2466:                if(lineno == MAXROW)
        !          2467:                        MoveTo(0, (lineno  +1) * height + 2 -descent );
        !          2468:                else
        !          2469:                        MoveTo(0, (lineno  +1) * height - descent);
        !          2470:                strncpy(buf + 1, curs, CO);
        !          2471:                buf[0] = (char) CO;
        !          2472:                DrawString(buf);
        !          2473:        }
        !          2474:        putcurs(trow,tcol,0);
        !          2475:        free(buf);
        !          2476: }
        !          2477: 
        !          2478: 
        !          2479: 
        !          2480: 
        !          2481: 
        !          2482: wc_adjust(w,h,wcf,init)                /* adjust window config to look nice */
        !          2483: struct wind_config *wcf;
        !          2484: {
        !          2485:        static int LIMIT_R, LIMIT_C;
        !          2486:        int rows, cols;
        !          2487: 
        !          2488:        if(init) {
        !          2489:                LIMIT_R = (h - 4) / HEIGHT;
        !          2490:                LIMIT_C = (w - SCROLLWIDTH - 1) / WIDTH + 1;
        !          2491:        }
        !          2492:        if((w < WIDTH * 40) ||(h < HEIGHT * 10) /* too small */
        !          2493:                || ((rows = (h - 4) / HEIGHT) > LIMIT_R)        /* too big */   
        !          2494:                || ((cols = (w - SCROLLWIDTH - 1) / WIDTH + 1) > LIMIT_C)) return(0);
        !          2495: 
        !          2496:        wcf->w_rows = rows;
        !          2497:        wcf->w_cols = cols;
        !          2498:        wcf->w_width = wcf->w_cols * WIDTH + 1 + SCROLLWIDTH;
        !          2499:        wcf->w_height = wcf->w_rows * HEIGHT + 4;
        !          2500:        return(1);
        !          2501: }
        !          2502: 
        !          2503: getCO()        /* so that jove knows params */
        !          2504: {
        !          2505:        return wc->w_cols;
        !          2506: }
        !          2507: 
        !          2508: getLI()
        !          2509: {
        !          2510:        return wc->w_rows;
        !          2511: }
        !          2512: 
        !          2513: static SetBounds()
        !          2514: {
        !          2515:        SetRect(&myBoundsRect,
        !          2516:                screenBits.bounds.left + 3,
        !          2517:                screenBits.bounds.top + 40,
        !          2518:                screenBits.bounds.left + 3 + wc_std.w_width,    
        !          2519:                screenBits.bounds.top + 40 + wc_std.w_height);
        !          2520: }
        !          2521: 
        !          2522: static Set_std()
        !          2523: {
        !          2524:        wc_adjust(screenBits.bounds.right - screenBits.bounds.left - 6, 
        !          2525:                screenBits.bounds.bottom - screenBits.bounds.top - 42,
        !          2526:                &wc_std,1);
        !          2527: }
        !          2528: 
        !          2529: static Reset_std()
        !          2530: {
        !          2531:        Set_std();
        !          2532:        std_state(theScreen) = myBoundsRect;
        !          2533: }
        !          2534: #endif /* MAC */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.