home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / EDITOR / J414SRC.ARC / MAC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-10-10  |  54.5 KB  |  2,535 lines
  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 */
  2535.