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