home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume17 / mgr / part20 < prev    next >
Text File  |  1989-01-19  |  52KB  |  1,993 lines
  1. Subject:  v17i021:  MGR, Bellcore window manager, Part21/61
  2. Newsgroups: comp.sources.unix
  3. Approved: rsalz@uunet.UU.NET
  4.  
  5. Submitted-by: Stephen A. Uhler <sau@bellcore.com>
  6. Posting-number: Volume 17, Issue 21
  7. Archive-name: mgr/part21
  8.  
  9.  
  10.  
  11.  
  12. #! /bin/sh
  13. # This is a shell archive.  Remove anything before this line, then unpack
  14. # it by saving it into a file and typing "sh file".  To overwrite existing
  15. # files, type "sh file -c".  You can also feed this as standard input via
  16. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  17. # will see the following message at the end:
  18. #        "End of archive 20 (of 61)."
  19. # Contents:  demo/misc/Makefile demo/misc/clock2.c src/blit/bitmap.c
  20. #   src/blit/line.C src/blit/sym.c src/destroy.c src/font_subs.c
  21. #   src/oblit/bitmap.c src/print.c src/win_make.c
  22. # Wrapped by rsalz@papaya.bbn.com on Thu Nov 17 21:05:23 1988
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. if test -f 'demo/misc/Makefile' -a "${1}" != "-c" ; then 
  25.   echo shar: Will not clobber existing file \"'demo/misc/Makefile'\"
  26. else
  27. echo shar: Extracting \"'demo/misc/Makefile'\" \(4414 characters\)
  28. sed "s/^X//" >'demo/misc/Makefile' <<'END_OF_FILE'
  29. X#                        Copyright (c) 1987 Bellcore
  30. X#                            All Rights Reserved
  31. X#       Permission is granted to copy or use this program, EXCEPT that it
  32. X#       may not be sold for profit, the copyright notice must be reproduced
  33. X#       on copies, and credit should be given to Bellcore where it is due.
  34. X#       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  35. X
  36. X#    $Header: Makefile,v 4.5 88/08/22 10:30:44 sau Exp $
  37. X#    $Source: /tmp/mgrsrc/demo/misc/RCS/Makefile,v $
  38. X
  39. X# makefile for demos 
  40. X
  41. XLIB= ../../lib/libmgr.a
  42. XBIT= ../../lib/blitlib.a
  43. XINCL= -I../../lib
  44. XCPIO=demo.cpio
  45. XTAR = demo.tar
  46. XCFLAGS=-O $(INCL)
  47. XLDFLAGS=$(LIB)
  48. XSTART=.
  49. XCPIO=misc.cpio
  50. XINSROOT=/usr/mgr
  51. XINSDIR=$(INSROOT)/bin
  52. X
  53. XCFILES= art_data.c bounce.c clock.c clock2.c close.c \
  54. X    dmgr.c ether.c getpty.c grav.c grid.c hilbert.c hpmgr.c maze.c \
  55. X    mgrmail.c mgrmode.c mgrmsgs.c oclose.c omgrmail.c overlayd.c \
  56. X    set_console.c set_emacs.c set_termcap.c show.c startup.c \
  57. X    stat.c stringart.c  lock.c
  58. X
  59. XOFILES= art_data.o bounce.o clock.o clock2.o close.o \
  60. X    dmgr.o ether.o getpty.o grav.o grid.o hilbert.o hpmgr.o maze.o \
  61. X    mgrmail.o mgrmode.o mgrmsgs.o oclose.o omgrmail.o overlayd.o \
  62. X    set_console.o set_emacs.o set_termcap.o show.o startup.o \
  63. X    stat.o stringart.o lock.o
  64. X
  65. XSMALL=    bounce clock clock2 close dmgr ether grav grid hilbert \
  66. X    hpmgr maze mgrmail mgrmode mgrmsgs oclose omgrmail \
  67. X    set_emacs set_termcap show startup stat stringart 
  68. X
  69. XALL = $(SMALL) overlayd set_console lock
  70. X
  71. XOTHER = Makefile
  72. X
  73. Xall:        $(ALL)
  74. X
  75. Xsmall:        $(SMALL)
  76. X
  77. Xfast:
  78. X        cc -c $(CFLAGS) $(CFILES)
  79. X        make all
  80. X
  81. Xbanner:        banner.o $(LIB)
  82. X        cc $(CFLAGS) -o banner banner.o $(LDFLAGS)
  83. X
  84. Xclock:        clock.o $(LIB)
  85. X        cc $(CFLAGS) -o clock clock.o $(LDFLAGS)
  86. X
  87. Xclock2:        clock2.o $(LIB)
  88. X        cc $(CFLAGS) -o clock2 clock2.o $(LDFLAGS)
  89. X
  90. Xbounce:        bounce.o $(LIB)
  91. X        cc $(CFLAGS) -o bounce bounce.o $(LDFLAGS)
  92. X
  93. Xdmgr:        dmgr.o $(LIB)
  94. X        cc $(CFLAGS) -o dmgr dmgr.o $(LDFLAGS)
  95. X
  96. Xgrav:        grav.o $(LIB)
  97. X        cc $(CFLAGS) -o grav grav.o $(LDFLAGS)
  98. X
  99. Xhpmgr:        hpmgr.o getpty.o $(LIB)
  100. X        cc $(CFLAGS) -o hpmgr hpmgr.o getpty.o $(LDFLAGS)
  101. X
  102. Xmgrmsgs:    mgrmsgs.o $(LIB)
  103. X        cc $(CFLAGS) -o mgrmsgs mgrmsgs.o $(LDFLAGS)
  104. X
  105. Xomgrmail:    omgrmail.o $(LIB)
  106. X        cc $(CFLAGS) -o omgrmail omgrmail.o $(LDFLAGS)
  107. X
  108. Xmgrmail:    mgrmail.o $(LIB)
  109. X        cc $(CFLAGS) -o mgrmail mgrmail.o $(LDFLAGS)
  110. X
  111. Xchart:        chart.o $(LIB)
  112. X        cc $(CFLAGS) -o chart chart.o $(LDFLAGS)
  113. X
  114. Xclose:        close.o $(LIB)
  115. X        cc $(CFLAGS) -o close close.o $(LDFLAGS)
  116. X
  117. Xoclose:        oclose.o $(LIB)
  118. X        cc $(CFLAGS) -o oclose oclose.o $(LDFLAGS)
  119. X
  120. Xclose3:        close3.o $(LIB)
  121. X        cc $(CFLAGS) -o close3 close3.o $(LDFLAGS)
  122. X
  123. Xstringart:    stringart.o art_data.o $(LIB)
  124. X        cc $(CFLAGS) -o stringart stringart.o art_data.o $(LDFLAGS)
  125. X
  126. Xstat:        stat.o $(LIB)
  127. X        cc $(CFLAGS) -o stat stat.o $(LDFLAGS)
  128. X
  129. Xether:        ether.o $(LIB)
  130. X        cc $(CFLAGS) -o ether ether.o $(LDFLAGS)
  131. X
  132. Xset_console:    set_console.o $(LIB)
  133. X        cc $(CFLAGS) -o set_console set_console.o $(LDFLAGS)
  134. X
  135. Xset_emacs:    set_emacs.o $(LIB)
  136. X        cc $(CFLAGS) -o set_emacs set_emacs.o $(LDFLAGS)
  137. X
  138. Xset_termcap:    set_termcap.o $(LIB)
  139. X        cc $(CFLAGS) -o set_termcap set_termcap.o $(LDFLAGS)
  140. X
  141. Xmgrmode:    mgrmode.o $(LIB)
  142. X        cc $(CFLAGS) -o mgrmode mgrmode.o $(LDFLAGS)
  143. X
  144. Xshow:        show.o $(LIB)
  145. X        cc $(CFLAGS) -o show show.o $(LDFLAGS)
  146. X
  147. Xstartup:    startup.o $(LIB)
  148. X        cc $(CFLAGS) -o startup startup.o $(LDFLAGS)
  149. X
  150. Xhilbert:    hilbert.o $(LIB)
  151. X        cc $(CFLAGS) -o hilbert hilbert.o $(LDFLAGS)
  152. X
  153. Xoverlayd:    overlayd.o $(LIB)
  154. X        cc $(CFLAGS) -o overlayd overlayd.o $(LDFLAGS)
  155. X
  156. Xgrid:        grid.o $(LIB)
  157. X        cc $(CFLAGS) -o grid grid.o $(LDFLAGS)
  158. X
  159. Xview:        view.o $(LIB)
  160. X        cc $(CFLAGS) -o view view.o $(LDFLAGS)
  161. X
  162. Xfile:        file.o $(LIB)
  163. X        cc $(CFLAGS) -o file file.o $(LDFLAGS)
  164. X
  165. Xprint:        print.o $(LIB)
  166. X        cc $(CFLAGS) -o print print.o $(LDFLAGS)
  167. X
  168. Xwprint:        wprint.o $(LIB)
  169. X        cc $(CFLAGS) -o wprint wprint.o $(LDFLAGS)
  170. X
  171. Xlock:        lock.o $(LIB)
  172. X        cc $(CFLAGS) -o lock lock.o $(BIT) $(OTHERLIB)
  173. X
  174. Xmaze:        maze.o $(LIB)
  175. X        cc $(CFLAGS) -o maze maze.o $(LDFLAGS)
  176. X
  177. X$(OFILES):    ../../lib/term.h $(LIB)
  178. X
  179. Xinstall:    all $(INSDIR)
  180. X        cd $(INSDIR);  rm -f $(ALL)
  181. X        cp $(ALL) $(INSDIR)
  182. X
  183. Xsmallinstall:    small $(INSDIR)
  184. X        cd $(INSDIR);  rm -f $(SMALL)
  185. X        cp $(SMALL) $(INSDIR)
  186. X        -/etc/chown root $(INSDIR)/maze  &&  chmod u+s $(INSDIR)/maze
  187. X
  188. X$(INSDIR):
  189. X    mkdir $@
  190. X
  191. Xtar:           
  192. X        tar cf $(TAR) `ls $(CFILES) $(SH) $(OTHER)`
  193. X
  194. Xclean:        
  195. X        rm -f *.o
  196. X
  197. Xclobber:        
  198. X        rm -f $(ALL)
  199. X
  200. Xlist:
  201. X    @for i in ${CFILES} ${HFILES} ${OTHER}; do \
  202. X        echo "${START}/$$i"; \
  203. X    done    
  204. X
  205. Xcpio:
  206. X    make -s list | cpio -ocv > ${CPIO}
  207. END_OF_FILE
  208. # end of 'demo/misc/Makefile'
  209. fi
  210. if test -f 'demo/misc/clock2.c' -a "${1}" != "-c" ; then 
  211.   echo shar: Will not clobber existing file \"'demo/misc/clock2.c'\"
  212. else
  213. echo shar: Extracting \"'demo/misc/clock2.c'\" \(5054 characters\)
  214. sed "s/^X//" >'demo/misc/clock2.c' <<'END_OF_FILE'
  215. X/*                        Copyright (c) 1987 Bellcore
  216. X *                            All Rights Reserved
  217. X *       Permission is granted to copy or use this program, EXCEPT that it
  218. X *       may not be sold for profit, the copyright notice must be reproduced
  219. X *       on copies, and credit should be given to Bellcore where it is due.
  220. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  221. X */
  222. X/*    $Header: clock2.c,v 4.2 88/06/22 14:37:27 bianchi Exp $
  223. X    $Source: /tmp/mgrsrc/demo/misc/RCS/clock2.c,v $
  224. X*/
  225. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/demo/misc/RCS/clock2.c,v $$Revision: 4.2 $";
  226. X
  227. X/* get today's date  (analog clock version) */
  228. X
  229. X#include <errno.h>
  230. X#include <time.h>
  231. X#include <stdio.h>
  232. X#include "term.h"
  233. X#include "restart.h"
  234. X
  235. X#define OFFSET        (500<<10)        /* shift points to 1st quad */
  236. X
  237. X/* sin, cos tables: 0-360 deg. in 6 deg. increments (scaled to +/- 1024) */
  238. X
  239. Xint sin[] = {
  240. X     0, 107, 212, 316, 416, 512,
  241. X     601, 685, 760, 828, 886, 935,
  242. X     973, 1001, 1018, 1023, 1018, 1001,
  243. X     973, 935, 886, 828, 760, 685,
  244. X     601, 511, 416, 316, 212, 107,
  245. X     0, -107, -212, -316, -416, -512,
  246. X     -601, -685, -760, -828, -886, -935,
  247. X     -973, -1001, -1018, -1023, -1018, -1001,
  248. X     -973, -935, -886, -828, -760, -685,
  249. X     -601, -511, -416, -316, -212, -107,
  250. X     0 };
  251. X
  252. X
  253. Xint cos[] = {
  254. X     1023, 1018, 1001, 973, 935, 886,
  255. X     828, 760, 685, 601, 511, 416,
  256. X     316, 212, 107, 0, -107, -212,
  257. X     -316, -416, -512, -601, -685, -760,
  258. X     -828, -886, -935, -973, -1001, -1018,
  259. X     -1023, -1018, -1001, -973, -935, -886,
  260. X     -828, -760, -685, -601, -511, -416,
  261. X     -316, -212, -107, 0, 107, 212,
  262. X     316, 416, 512, 601, 685, 760,
  263. X     828, 886, 935, 973, 1001, 1018,
  264. X     1023 };
  265. X
  266. Xtypedef struct coord {
  267. X    int x,y;
  268. X    } coord;
  269. X
  270. X/* coordinates of the hands at 12:00 */
  271. X
  272. Xcoord second[] = { 1,-30,  0,485 };
  273. Xcoord minute[] = { 10,-10,  0,400,  -10,-10,  10,-10 };
  274. Xcoord hour[] = { 35,-10,  0,270,  -35,-10,  35,-10 };
  275. X
  276. Xcoord big_tic[] = { -11,485,  0,450,  11,485 };
  277. Xcoord tic[] = { 0,485,  0,460 };
  278. X
  279. Xint h, old_h, m, old_m, s, old_s;
  280. X
  281. Xmain(argc,argv)
  282. Xint argc;
  283. Xchar **argv;
  284. X   {
  285. X   register int i;
  286. X   int cal=0;
  287. X   int dotime(), clean();
  288. X   char line[80];
  289. X
  290. X   ckmgrterm( *argv );
  291. X
  292. X   if (argc>1 && strcmp(argv[1],"-c")==0)
  293. X      cal++;
  294. X
  295. X   /* setup mgr environment */
  296. X
  297. X   m_setup(0);
  298. X   m_push(P_FLAGS|P_EVENT);
  299. X   m_ttyset();
  300. X
  301. X   m_setevent(REDRAW,"R\r");
  302. X   m_setevent(RESHAPE,"R\r");
  303. X   if (cal)
  304. X      m_setevent(ACTIVATE,"A\r");
  305. X
  306. X   signal(SIGALRM,dotime);
  307. X   signal(SIGTERM,clean);
  308. X   signal(SIGINT,clean);
  309. X   signal(SIGHUP,clean);
  310. X
  311. X   while(1) {
  312. X      m_func(B_SET);
  313. X      m_clear();
  314. X      m_ellipse(500,500,490,490);
  315. X      for(i=0;i<60;i+=5)         /* the tic marks */
  316. X         if (i%15==0)
  317. X            draw(big_tic,2,i);
  318. X         else
  319. X            draw(tic,1,i);
  320. X   
  321. X      m_movecursor(500,500);
  322. X      get_time(&h, &m, &s);
  323. X
  324. X      draw(hour,3,h);
  325. X      draw(minute,3,m);
  326. X
  327. X      m_func(B_INVERT);
  328. X      draw(second,1,s);
  329. X      m_flush();
  330. X      dotime();
  331. X
  332. X      /* wait for an event */
  333. X
  334. X      while(1) {
  335. X     extern int   errno;
  336. X
  337. X         errno = 0;
  338. X     *line = '\0';
  339. X         if (m_gets(line) == NULL  &&  errno  &&  errno != EINTR)
  340. X            clean(0);
  341. X         alarm(0);
  342. X         if (*line=='R')
  343. X            break;
  344. X         else if (cal && *line == 'A') {
  345. X            long time(), tmp = time(0);
  346. X            char *ctime();
  347. X
  348. X            m_push(P_ALL);
  349. X            m_font(11);
  350. X            m_size(27,3);
  351. X            m_clear();
  352. X            m_printstr("\n "); 
  353. X            m_printstr(ctime(&tmp));
  354. X            m_flush();
  355. X            sleep(3);
  356. X            m_pop();
  357. X            m_clearmode(M_ACTIVATE);
  358. X            m_flush();
  359. X            }
  360. X         dotime();
  361. X         }
  362. X      }
  363. X   }
  364. X
  365. X/* update the time */
  366. X
  367. Xint
  368. Xdotime()
  369. X   {
  370. X   old_h=h, old_m=m, old_s=s;
  371. X   get_time(&h, &m, &s);
  372. X
  373. X   draw(second,1,old_s);
  374. X   if (old_m != m) {
  375. X      m_func(B_CLEAR);
  376. X      draw(minute,3,old_m);
  377. X      draw(hour,3,old_h);
  378. X 
  379. X      m_func(B_SET);
  380. X      draw(hour,3,h);
  381. X      draw(minute,3,m);
  382. X      m_func(B_INVERT);
  383. X      }
  384. X
  385. X   draw(second,1,s);
  386. X   m_flush();
  387. X   signal(SIGALRM,dotime);
  388. X   alarm(1);
  389. X   }
  390. X
  391. X/* rotate and draw hands */
  392. X   
  393. X#define X(i)    (what[i].x)
  394. X#define Y(i)    (what[i].y)
  395. X
  396. Xdraw(what, n, theta)
  397. Xcoord what[];            /* array of points */
  398. Xint n;                /* number of points */
  399. Xint theta;            /* angle (in 160th of a circle) */
  400. X   {
  401. X   register int i;
  402. X
  403. X   for(i=0;i<n;i++) {
  404. X      m_line((X(i)*cos[theta]+Y(i)*sin[theta] + OFFSET)>>10,
  405. X           (X(i)*sin[theta]-Y(i)*cos[theta] + OFFSET)>>10,
  406. X           (X(i+1)*cos[theta]+Y(i+1)*sin[theta] + OFFSET)>>10,
  407. X           (X(i+1)*sin[theta]-Y(i+1)*cos[theta] + OFFSET)>>10);
  408. X           }
  409. X   }
  410. X
  411. X/* convert time to angles */
  412. X
  413. Xget_time(h,m,s)
  414. Xint *h, *m, *s;        /* hours, minutes, seconds */
  415. X   {
  416. X   struct tm *tme, *localtime();
  417. X   long tmp,time();
  418. X    
  419. X   tmp = time(0);
  420. X   tme = localtime(&tmp);
  421. X
  422. X   *m = tme->tm_min;
  423. X   *s = tme->tm_sec;
  424. X   if (tme->tm_hour > 11)
  425. X      tme->tm_hour -= 12;
  426. X   *h = tme->tm_hour*5 + (2+tme->tm_min)/12;
  427. X   }
  428. X
  429. X/* clean up and exit */
  430. X
  431. Xclean(n)
  432. Xint    n;
  433. X   {
  434. X   m_popall(0);
  435. X   m_clear();
  436. X   m_flush();
  437. X   m_ttyreset();
  438. X   exit(1);
  439. X   }
  440. END_OF_FILE
  441. # end of 'demo/misc/clock2.c'
  442. fi
  443. if test -f 'src/blit/bitmap.c' -a "${1}" != "-c" ; then 
  444.   echo shar: Will not clobber existing file \"'src/blit/bitmap.c'\"
  445. else
  446. echo shar: Extracting \"'src/blit/bitmap.c'\" \(4616 characters\)
  447. sed "s/^X//" >'src/blit/bitmap.c' <<'END_OF_FILE'
  448. X/*                        Copyright (c) 1987 Bellcore
  449. X *                            All Rights Reserved
  450. X *       Permission is granted to copy or use this program, EXCEPT that it
  451. X *       may not be sold for profit, the copyright notice must be reproduced
  452. X *       on copies, and credit should be given to Bellcore where it is due.
  453. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  454. X */
  455. X/*    $Header: bitmap.c,v 4.2 88/07/07 09:04:29 sau Exp $
  456. X    $Source: /tmp/mgrsrc/src/blit/RCS/bitmap.c,v $
  457. X*/
  458. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/blit/RCS/bitmap.c,v $$Revision: 4.2 $";
  459. X
  460. X/*  SUN-2  and SUN-3 bitblit code */
  461. X
  462. X#ifdef sun
  463. X#  include <sys/ioctl.h>
  464. X#  include <sun/fbio.h>
  465. X#  include <sys/file.h>
  466. X#  include <sys/mman.h>
  467. X#endif
  468. X#include <stdio.h>
  469. X#include "bitmap.h"
  470. X
  471. Xint bit_debug = 1;
  472. Xstatic int _s_start;
  473. Xstatic _s_len;
  474. X
  475. X/* open the screen; it looks like memory */
  476. X
  477. XBITMAP *
  478. Xbit_open(name)
  479. Xchar *name;            /* name of frame buffer */
  480. X{
  481. X   BITMAP *result = BIT_NULL;
  482. X#ifdef sun
  483. X   int fd;
  484. X   char *malloc();
  485. X   register DATA addr;
  486. X   struct fbtype buff;
  487. X   int pagesize;
  488. X
  489. X   Bprintf(1) ("bit_open:(%s)\n", name);
  490. X
  491. X   /* open the SUN screen */
  492. X
  493. X   if ((fd = open(name, O_RDWR)) < 0)
  494. X      return (BIT_NULL);
  495. X
  496. X   /* get the frame buffer size */
  497. X
  498. X   if (ioctl(fd, FBIOGTYPE, &buff) < 0)
  499. X      return (BIT_NULL);
  500. X
  501. X   /* malloc space for frame buffer */
  502. X
  503. X   pagesize = getpagesize();
  504. X   if ((_s_start = (int) malloc(buff.fb_size + pagesize)) == 0)
  505. X      return (BIT_NULL);
  506. X
  507. X   /* align space on a page boundary */
  508. X
  509. X   buff.fb_size = (buff.fb_size+pagesize-1) &~ (pagesize-1);
  510. X   addr = (DATA ) ((_s_start + pagesize - 1) & ~(pagesize - 1));
  511. X
  512. X   /* map the frame buffer into malloc'd space */
  513. X
  514. X#ifdef _MAP_NEW        /* New semantics for mmap in Sun release 4.0 */
  515. X   addr = (DATA) mmap(addr, _s_len=buff.fb_size,
  516. X                         PROT_WRITE, _MAP_NEW|MAP_SHARED, fd, 0);
  517. X   if ((int)addr == -1)
  518. X      return (BIT_NULL);
  519. X#else
  520. X   if (mmap(addr, _s_len = buff.fb_size, PROT_WRITE, MAP_SHARED, fd, 0) < 0)
  521. X      return (BIT_NULL);
  522. X#endif
  523. X
  524. X   if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  525. X      return (BIT_NULL);
  526. X
  527. X   result->primary = result;
  528. X   result->data = addr;
  529. X   result->x0 = 0,
  530. X      result->y0 = 0,
  531. X      result->wide = buff.fb_width;
  532. X   result->high = buff.fb_height;
  533. X   result->type = _SCREEN;
  534. X   Bprintf(2) ("  O.K.(0x%lx)\n (%d x %x)",
  535. X           (long) result->data, result->wide, result->high);
  536. X#endif
  537. X   return (result);
  538. X}
  539. X
  540. X/* destroy a bitmap, free up space */
  541. X
  542. Xint
  543. Xbit_destroy(bitmap)
  544. XBITMAP *bitmap;
  545. X{
  546. X   Bprintf(1) ("bit_destroy:\n");
  547. X   if (bitmap == (BITMAP *) 0)
  548. X      return (-1);
  549. X   if (IS_MEMORY(bitmap) && IS_PRIMARY(bitmap))
  550. X      free(bitmap->data);
  551. X   else if (IS_SCREEN(bitmap) && IS_PRIMARY(bitmap)) {
  552. X      munmap(BIT_DATA(bitmap), _s_len);
  553. X      free(_s_start);
  554. X   }
  555. X   free(bitmap);
  556. X   return (0);
  557. X}
  558. X
  559. X/* create a bitmap as a sub-rectangle of another bitmap */
  560. X
  561. XBITMAP *
  562. Xbit_create(map, x, y, wide, high)
  563. XBITMAP *map;
  564. Xint x, y, wide, high;
  565. X{
  566. X   char *malloc();
  567. X   register BITMAP *result;
  568. X
  569. X   Bprintf(1) ("bit_create:\n");
  570. X   if (x + wide > map->wide)
  571. X      wide = map->wide - x;
  572. X   if (y + high > map->high)
  573. X      high = map->high - y;
  574. X   if (wide < 1 || high < 1)
  575. X      return (BIT_NULL);
  576. X
  577. X   if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  578. X      return (BIT_NULL);
  579. X
  580. X   result->data = map->data;
  581. X   result->x0 = map->x0 + x;
  582. X   result->y0 = map->y0 + y;
  583. X   result->wide = wide;
  584. X   result->high = high;
  585. X   result->primary = map->primary;
  586. X   result->type = map->type;
  587. X   Bprintf(2) ("  Created %d,%d %d,%d\n", result->x0, result->y0,
  588. X           result->wide, result->high);
  589. X   return (result);
  590. X}
  591. X
  592. X/* allocate space for, and create a memory bitmap */
  593. X
  594. XBITMAP *
  595. Xbit_alloc(wide, high, data, bits)
  596. Xunsigned short wide, high;
  597. XDATA data;
  598. Xint bits;    /* in preparation for color */
  599. X{
  600. X   char *malloc();
  601. X   register BITMAP *result;
  602. X   register int size;
  603. X
  604. X   Bprintf(1) ("bit_alloc:\n");
  605. X   if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  606. X      return (result);
  607. X
  608. X   result->x0 = 0;
  609. X   result->y0 = 0;
  610. X   result->high = high;
  611. X   result->wide = wide;
  612. X
  613. X   size = BIT_SIZE(result);
  614. X
  615. X   if (data != (DATA ) 0)
  616. X      result->data = data;
  617. X#ifdef ALIGN32
  618. X   else if ((result->data = (DATA ) memalign(4,size)) == (DATA ) 0) {
  619. X#else
  620. X   else if ((result->data = (DATA ) malloc(size)) == (DATA ) 0) {
  621. X#endif
  622. X      free(result);
  623. X      return ((BITMAP *) 0);
  624. X   }
  625. X
  626. X   result->primary = result;
  627. X   result->type = _MEMORY;
  628. X   Bprintf(2) ("  Created %d,%d %d,%d\n", result->x0, result->y0,
  629. X           result->wide, result->high);
  630. X   return (result);
  631. X}
  632. END_OF_FILE
  633. # end of 'src/blit/bitmap.c'
  634. fi
  635. if test -f 'src/blit/line.C' -a "${1}" != "-c" ; then 
  636.   echo shar: Will not clobber existing file \"'src/blit/line.C'\"
  637. else
  638. echo shar: Extracting \"'src/blit/line.C'\" \(4306 characters\)
  639. sed "s/^X//" >'src/blit/line.C' <<'END_OF_FILE'
  640. X/*                        Copyright (c) 1988 Bellcore
  641. X *                            All Rights Reserved
  642. X *       Permission is granted to copy or use this program, EXCEPT that it
  643. X *       may not be sold for profit, the copyright notice must be reproduced
  644. X *       on copies, and credit should be given to Bellcore where it is due.
  645. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  646. X */
  647. X/*    $Header: line.C,v 4.2 88/06/30 11:40:57 sau Exp $
  648. X    $Source: /tmp/mgrsrc/src/blit/RCS/line.C,v $
  649. X*/
  650. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/blit/RCS/line.C,v $$Revision: 4.2 $";
  651. X
  652. X#include "asm.h"
  653. X#include "bitmap.h"
  654. X
  655. X/*  Draw a line  - Bresenham method using bit-field instructions.
  656. X *  The bitfield instructions don't buy much (<10%), but they're there.
  657. X */
  658. X
  659. Xbit_line(dest, x0, y0, x1, y1, func)
  660. Xregister BITMAP *dest;                /* destination bitmap */    
  661. Xint x0, y0, x1, y1;            /* line coordinates */
  662. Xint func;                    /* set, clear, or invert */
  663. X   {
  664. X   register int err, rincr, rdecr, d_incr, count;
  665. X   register int offset;            /* bit offset from x0,y0 */
  666. X   register long *base;            /* address of x0,y0 */
  667. X   int dx, dy;                /* # of pixels in x and y */
  668. X   int temp;
  669. X
  670. X#ifndef NOCLIP
  671. X   /* clip here */
  672. X
  673. X#define TOP    001
  674. X#define BOTTOM    002
  675. X#define LEFT    004
  676. X#define RIGHT    010
  677. X#define CROSS(x,y) \
  678. X      (x<0 ? LEFT : x>= (dest->wide) ? RIGHT : 0) + \
  679. X      (y < 0 ? TOP : y >=  (dest -> high) ? BOTTOM : 0)
  680. X
  681. X      {
  682. X
  683. X      /* The classic line clipping algorithm */
  684. X
  685. X      int cross0 = CROSS(x0, y0);
  686. X      int cross1 = CROSS(x1, y1);
  687. X
  688. X      while (cross0 || cross1) {
  689. X          int cross, x, y;
  690. X          if (cross0 & cross1)
  691. X             return;
  692. X          if (cross0 != 0)
  693. X             cross = cross0;
  694. X          else
  695. X             cross = cross1;
  696. X          if (cross & (LEFT | RIGHT)) {
  697. X             int edge = (cross & LEFT) ? 0 : dest->wide - 1;
  698. X             y = y0 + (y1 - y0) * (edge - x0) / (x1 - x0);
  699. X             x = edge;
  700. X             }
  701. X          else if (cross & (TOP | BOTTOM)) {
  702. X             int edge = (cross & TOP) ? 0 : dest->high - 1;
  703. X             x = x0 + (x1 - x0) * (edge - y0) / (y1 - y0);
  704. X             y = edge;
  705. X             }
  706. X          if (cross == cross0) {
  707. X             x0 = x;
  708. X             y0 = y;
  709. X             cross0 = CROSS(x, y);
  710. X             }
  711. X          else {
  712. X             x1 = x;
  713. X             y1 = y;
  714. X             cross1 = CROSS(x, y);
  715. X             }
  716. X         }
  717. X      }
  718. X
  719. X   /* end of clipping */
  720. X#endif
  721. X
  722. X   x0 += dest->x0;
  723. X   y0 += dest->y0;
  724. X   x1 += dest->x0;
  725. X   y1 += dest->y0;
  726. X
  727. X   /* always draw left to right */
  728. X
  729. X   if (x1 < x0) {
  730. X      temp = x1, x1 = x0, x0 = temp;
  731. X      temp = y1, y1 = y0, y0 = temp;
  732. X      }
  733. X   dx = x1 - x0;
  734. X   dy = y1 - y0;
  735. X
  736. X   if (dy > 0)
  737. X      d_incr = BIT_LINE(dest);
  738. X   else
  739. X      d_incr = -BIT_LINE(dest), dy = -dy;
  740. X
  741. X   base = y0 * (BIT_LINE(dest) >> 5) + (dest->data);    /* start of line */
  742. X   offset = x0;            /* bit offset from line */
  743. X
  744. X#define STEP(dx,dy,xmove,ymove,op) {        \
  745. X    rincr = (dx - dy)<<1;            \
  746. X    rdecr = -(dy<<1);                \
  747. X    err = dx + rdecr;                \
  748. X    for (count = dx; count >= 0; count--) {    \
  749. X        op($base,$offset,IMM(1)); \
  750. X        offset  += (xmove);                        \
  751. X        if (err < 0) {                \
  752. X            offset += (ymove);                \
  753. X            err += rincr;                \
  754. X            }                    \
  755. X        else {                    \
  756. X            err += rdecr;                \
  757. X            }                    \
  758. X        }                     \
  759. X    }
  760. X
  761. X   /* @+ */
  762. X
  763. X   if (dx > dy)            /* gentle slope */
  764. X      switch (OPCODE(func)) {
  765. X     case OPCODE(SRC):
  766. X     case OPCODE(SRC | DST):
  767. X     case OPCODE(SRC | ~DST):
  768. X     case OPCODE(~0):
  769. X        STEP(dx, dy, 1, d_incr, BF_SET);
  770. X        break;
  771. X     case OPCODE(~SRC):
  772. X     case OPCODE(~(SRC|DST)):
  773. X     case OPCODE(DST & ~SRC):
  774. X     case OPCODE(0):
  775. X        STEP(dx, dy, 1, d_incr, BF_CLR);
  776. X        break;
  777. X     case OPCODE(SRC ^ DST):
  778. X     case OPCODE(~DST):
  779. X     case OPCODE(SRC & ~DST):
  780. X     case OPCODE(~(SRC&DST)):
  781. X        STEP(dx, dy, 1, d_incr, BF_INV);
  782. X        break;
  783. X         }
  784. X   else                /* steep slope */
  785. X      switch (OPCODE(func)) {
  786. X     case OPCODE(SRC):
  787. X     case OPCODE(SRC | DST):
  788. X     case OPCODE(SRC | ~DST):
  789. X     case OPCODE(~0):
  790. X        STEP(dy, dx, d_incr, 1, BF_SET);
  791. X        break;
  792. X     case OPCODE(~SRC):
  793. X     case OPCODE(~(SRC|DST)):
  794. X     case OPCODE(DST & ~SRC):
  795. X     case OPCODE(0):
  796. X        STEP(dy, dx, d_incr, 1, BF_CLR);
  797. X        break;
  798. X     case OPCODE(SRC ^ DST):
  799. X     case OPCODE(~DST):
  800. X     case OPCODE(SRC & ~DST):
  801. X     case OPCODE(~(SRC&DST)):
  802. X        STEP(dy, dx, d_incr, 1, BF_INV);
  803. X        break;
  804. X    }
  805. X   }
  806. END_OF_FILE
  807. # end of 'src/blit/line.C'
  808. fi
  809. if test -f 'src/blit/sym.c' -a "${1}" != "-c" ; then 
  810.   echo shar: Will not clobber existing file \"'src/blit/sym.c'\"
  811. else
  812. echo shar: Extracting \"'src/blit/sym.c'\" \(5117 characters\)
  813. sed "s/^X//" >'src/blit/sym.c' <<'END_OF_FILE'
  814. X/*                        Copyright (c) 1988 Bellcore
  815. X *                            All Rights Reserved
  816. X *       Permission is granted to copy or use this program, EXCEPT that it
  817. X *       may not be sold for profit, the copyright notice must be reproduced
  818. X *       on copies, and credit should be given to Bellcore where it is due.
  819. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  820. X */
  821. X/*    $Header: sym.c,v 4.1 88/06/21 13:19:15 bianchi Exp $
  822. X    $Source: /tmp/mgrsrc/src/blit/RCS/sym.c,v $
  823. X*/
  824. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/blit/RCS/sym.c,v $$Revision: 4.1 $";
  825. X
  826. X/* do symbolic substitution for asm decls SUN version */
  827. X
  828. X/*    sample stab entries
  829. X    .stabs    "x:r(0,1)",0x40,0,4,7
  830. X    .stabs    "i:r(0,1)",0x40,0,4,6
  831. X    .stabs    "d:r(0,13)",0x40,0,1,12
  832. X    .stabs    "s:r(0,13)=*(0,2)",0x40,0,1,13
  833. X   sample sun instruction
  834. X       bfins.l %d1, (%$dbase)[%$dst:%$field]
  835. X*/
  836. X
  837. X#include "stdio.h"
  838. X#include "hash.h"
  839. X
  840. X#define GET_OPT(i)   \
  841. X   strlen(argv[i])>2 ? argv[i]+2 : argv[++i]
  842. X
  843. X#define FMT    "    .stabs    \"%[^:]:r%*[^\"]\",0x%d,%*d,%*d,%s"
  844. X#define TSIZE        501            /* # of entries in hash table */
  845. X#define KEY    "#$ %s %s"        /* key work entry */
  846. X#define dprintf    if(debug)fprintf
  847. X
  848. Xchar line[512];            /* input line buffer */
  849. Xchar name[32];                /* parameter name */
  850. Xchar reg[10];                /* register value */
  851. X
  852. Xstruct table_entry *table[TSIZE];
  853. X
  854. Xmain(argc,argv)
  855. Xint argc;
  856. Xchar **argv;
  857. X   {
  858. X   int class;        /* storage class */
  859. X   int n;
  860. X   char *start, *end;    /* for finding sub's. */
  861. X   char *index(), *get_end();
  862. X   int value;        /* register value to substitute */
  863. X   int count = 0;    /* # of subs */
  864. X   int line_cnt=0;        /* input line # */
  865. X   char type;        /* register type 'a' or 'd' */
  866. X   int debug = 0;
  867. X   register int i;
  868. X
  869. X   for(i=1;i<argc;i++) {
  870. X      if (*argv[i] == '-')
  871. X         switch (argv[i][1]) {
  872. X            case 'd':            /* turn on debugging */
  873. X               debug++;
  874. X               break;
  875. X            case 'K':            /* add keyword */
  876. X                  { 
  877. X                  char *key = (GET_OPT(i));
  878. X                  char *reg = argv[++i];
  879. X                  add_entry(table,TSIZE,key);
  880. X                  put_entry(table,TSIZE,key,reg);
  881. X                  dprintf(stderr,"adding %s => %s from command line\n",key,reg);
  882. X                  }
  883. X               break;
  884. X            default:
  885. X               fprintf(stderr,"%s: bad flag %c ignored\n",argv[0],argv[i][1]);
  886. X            }
  887. X         }
  888. X
  889. X   dprintf(stderr,"Asm symbolic processor\n");
  890. X   while(gets(line) != NULL) {
  891. X      line_cnt++;
  892. X        n = sscanf(line,FMT,name,&class,reg);
  893. X        if (n==3 && class == 40) {                    /* declaration */
  894. X         if (is_entry(table,TSIZE,reg))  {        /* delete old name */
  895. X            dlt_entry(table,TSIZE,get_entry(table,TSIZE,reg));
  896. X            }
  897. X         add_entry(table,TSIZE,reg);
  898. X         add_entry(table,TSIZE,name);
  899. X         put_entry(table,TSIZE,name,reg);
  900. X         put_entry(table,TSIZE,reg,name);
  901. X         puts(line);
  902. X         dprintf(stderr,"adding %s => %s from stab entry\n",name,reg);
  903. X         }
  904. X      else if (sscanf(line,KEY,name,reg) == 2) {    /* keyword substitution */
  905. X         add_entry(table,TSIZE,name);
  906. X         put_entry(table,TSIZE,name,reg);
  907. X         dprintf(stderr,"adding %s => %s from file\n",name,reg);
  908. X         }
  909. X      else if (start = index(line,'$')) {                /* parameter substitution */
  910. X         fwrite(line,1,start-line,stdout);
  911. X         do {
  912. X            end = get_end(start+1);
  913. X            strncpy(name,start+1,end-start-1);
  914. X            name[end-start-1] = '\0';
  915. X            if (is_entry(table,TSIZE,name)) { /* do substitution */
  916. X               value = atoi(get_entry(table,TSIZE,name));
  917. X               if (value > 7) {
  918. X                  type = 'a';
  919. X                  value -=8;
  920. X                  }
  921. X               else
  922. X                  type = 'd';
  923. X               printf("%c%d",type,value);
  924. X               dprintf(stderr,"line %d: substituting <%c%d> for <%s>\n",
  925. X                       line_cnt,type,value,name);
  926. X               count++;
  927. X               }
  928. X            else if (is_reg(name))    {                            /* can't find sub */
  929. X               printf("%s",name);
  930. X               } 
  931. X            else {            
  932. X               printf("$%s",name);
  933. X               fprintf(stderr,"%s: Line %d no register found for %s\n",
  934. X                       *argv,line_cnt,name);
  935. X               }
  936. X            if (start = index(end,'$')) 
  937. X               fwrite(end,1,start-end,stdout);
  938. X            else
  939. X               printf("%s\n",end);
  940. X            }
  941. X         while(start);
  942. X         }
  943. X      else                                                            /* pass through */
  944. X         puts(line);
  945. X      }
  946. X   dprintf(stderr,"%d substitutions made on %d lines\n",count,line_cnt);
  947. X   exit(0);
  948. X   }
  949. X
  950. X/* find end of word */
  951. X
  952. Xchar *
  953. Xget_end(str)
  954. Xchar *str;
  955. X   {
  956. X   register char c;
  957. X   register int i=0;
  958. X
  959. X   while (i++,(c = *str++)) {
  960. X      if (c>='a' && c<='z') continue;
  961. X      if (c>='A' && c <= 'Z') continue;
  962. X      if (i>1 && c>='0' && c <= '9') continue;
  963. X      if (c != '_') break;
  964. X      }
  965. X   return(str-1);
  966. X   }
  967. X
  968. X/* see if variable is [ad][0-7] */
  969. X
  970. Xint
  971. Xis_reg(name)
  972. Xchar *name;
  973. X   {
  974. X   return( (name[0]=='d' || name[1] == 'a') &&
  975. X           (name[1] >= '0' && name[1] <= '7'));
  976. X   }
  977. END_OF_FILE
  978. # end of 'src/blit/sym.c'
  979. fi
  980. if test -f 'src/destroy.c' -a "${1}" != "-c" ; then 
  981.   echo shar: Will not clobber existing file \"'src/destroy.c'\"
  982. else
  983. echo shar: Extracting \"'src/destroy.c'\" \(5076 characters\)
  984. sed "s/^X//" >'src/destroy.c' <<'END_OF_FILE'
  985. X/*                        Copyright (c) 1987 Bellcore
  986. X *                            All Rights Reserved
  987. X *       Permission is granted to copy or use this program, EXCEPT that it
  988. X *       may not be sold for profit, the copyright notice must be reproduced
  989. X *       on copies, and credit should be given to Bellcore where it is due.
  990. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  991. X */
  992. X/*    $Header: destroy.c,v 4.1 88/06/21 13:21:40 bianchi Exp $
  993. X    $Source: /tmp/mgrsrc/src/RCS/destroy.c,v $
  994. X*/
  995. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/RCS/destroy.c,v $$Revision: 4.1 $";
  996. X
  997. X/* destroy a window (needs fixing) */
  998. X
  999. X#include "bitmap.h"
  1000. X#include <stdio.h>     /* temporary */
  1001. X#include <sys/wait.h>
  1002. X#include <sys/signal.h>
  1003. X#include "defs.h"
  1004. X#include "font.h"
  1005. X#include "event.h"
  1006. X
  1007. X#define ALL    1
  1008. X
  1009. X/* mark active window for destruction */
  1010. X
  1011. Xint destroy_window()
  1012. X   {
  1013. X   ACTIVE(flags) |= W_DIED;
  1014. X   }
  1015. X
  1016. X/* destroy a window */
  1017. X
  1018. Xint destroy(win)
  1019. Xregister WINDOW *win;
  1020. X   {
  1021. X   int i;
  1022. X   union wait status;
  1023. X
  1024. X   if (win == (WINDOW *) 0)
  1025. X      return(-1);
  1026. X
  1027. X   MOUSE_OFF(mousex,mousey);
  1028. X   cursor_off();
  1029. X
  1030. X   if (win != active) {
  1031. X      ACTIVE_OFF();
  1032. X      expose(win);
  1033. X      }
  1034. X
  1035. X   active = W(next);
  1036. X
  1037. X   /* deallocate window slot */
  1038. X
  1039. X   if (active)
  1040. X      ACTIVE(prev) = W(prev);
  1041. X
  1042. X   /* remove window from screen */
  1043. X
  1044. X   erase_win(W(border));
  1045. X
  1046. X   if (W(main)==win) {        /* kill process associated with the window */
  1047. X#ifdef DEBUG
  1048. X      dprintf(d)(stderr,"%s: destroy main %s\r\n",W(tty),W(alt)?"ALT":"");
  1049. X#endif
  1050. X      killpg(W(pid),SIGHUP);
  1051. X
  1052. X      if (geteuid() < 1) {
  1053. X         chmod(W(tty),0666);
  1054. X         chown(W(tty),0,0);
  1055. X         }
  1056. X
  1057. X      close(W(to_fd));
  1058. X      mask &= ~(1<<W(to_fd));
  1059. X      poll &= ~(1<<W(to_fd));
  1060. X#ifdef WHO
  1061. X      rm_utmp(W(tty));
  1062. X#endif
  1063. X
  1064. X      /* tell alternate windows main died */
  1065. X
  1066. X      set_dead(win);
  1067. X
  1068. X      /* wait for shell to die */
  1069. X
  1070. X#ifdef DEBUG
  1071. X      dprintf(d)(stderr,"waiting for ..."); fflush(stderr);
  1072. X#endif
  1073. X      if (W(pid) > 1) {
  1074. X         i = wait3(&status,WNOHANG,0L);
  1075. X         if (i == 0) {                     /* start it so it can die */
  1076. X            kill(W(pid),SIGCONT);
  1077. X            wait(&status);
  1078. X            }
  1079. X         }
  1080. X#ifdef DEBUG
  1081. X      dprintf(d)(stderr," %d\r\n",i);
  1082. X#endif
  1083. X      next_window--; 
  1084. X      }
  1085. X
  1086. X   else if (W(main) && !(W(main)->flags&W_DIED)) {    /* main still alive */
  1087. X#ifdef DEBUG
  1088. X      dprintf(d)(stderr,"%s: destroy alt %d\r\n",W(tty),W(num));
  1089. X#endif
  1090. X      do_event(EVENT_DESTROY,win,E_MAIN);
  1091. X      if (W(from_fd)) {        /* re-attach output to main window */
  1092. X         W(main)->from_fd = W(main)->to_fd;
  1093. X         W(main)->max = W(max) - W(current); /* ??? */
  1094. X#ifdef DEBUG
  1095. X      dprintf(d)(stderr,"%s: copy %d chars at %d\r\n",
  1096. X               W(main)->max, W(current));
  1097. X#endif
  1098. X         bcopy(W(buff)+W(current)+1,W(main)->buff,W(main)->max);
  1099. X         W(main)->current = 0;
  1100. X#ifdef DEBUG
  1101. X         dprintf(d)(stderr,"%s: reattaching main %d chars\r\n",W(tty),W(max));
  1102. X#endif
  1103. X         }
  1104. X      detach(win);
  1105. X      }
  1106. X   else if (W(main)) {        /* tell main alts know they are dead */
  1107. X      W(main)->alt = (WINDOW *) 0;
  1108. X#ifdef DEBUG
  1109. X      dprintf(d)(stderr,"%s: destroy alt, (tell main)\r\n",W(tty));
  1110. X#endif
  1111. X      }
  1112. X   else {
  1113. X#ifdef DEBUG
  1114. X      dprintf(d)(stderr,"%s: destroy alt, (dead main)\r\n",W(tty));
  1115. X#endif
  1116. X      }
  1117. X
  1118. X   /* fix up display if any windows left */
  1119. X
  1120. X   if (active) {
  1121. X      repair(win);
  1122. X      un_covered();
  1123. X      clip_bad(win);    /* invalidate clip lists */
  1124. X      ACTIVE_ON();
  1125. X      cursor_on();
  1126. X      }
  1127. X
  1128. X   /* free space associated with dead window */
  1129. X
  1130. X   unlink_win(win,ALL);
  1131. X
  1132. X#ifdef DEBUG
  1133. X   dprintf(d)(stderr,"Active: %s-%d\r\n",
  1134. X          active?ACTIVE(tty):"NONE", active?ACTIVE(num):0);
  1135. X#endif
  1136. X
  1137. X   MOUSE_ON(mousex,mousey);
  1138. X
  1139. X   return(0);
  1140. X   }
  1141. X
  1142. X/* free all space associated with a window */
  1143. X
  1144. Xunlink_win(win,how)
  1145. Xregister WINDOW *win;        /* window to unlink */
  1146. Xint how;            /* if how, unlink window stack as well */
  1147. X   {
  1148. X   register int i;
  1149. X
  1150. X#ifdef DEBUG
  1151. X   dprintf(u)(stderr,"Unlinking %s %s\n",W(tty),how?"ALL":"");
  1152. X#endif
  1153. X
  1154. X   if (how && W(stack))
  1155. X      unlink_win(W(stack),how);
  1156. X   if (W(window))
  1157. X       bit_destroy(W(window));
  1158. X   for(i=0; i< MAXBITMAPS;i++) 
  1159. X      if (W(bitmaps)[i])
  1160. X          bit_destroy(W(bitmaps)[i]);
  1161. X   if (W(border))
  1162. X       bit_destroy(W(border));
  1163. X   if (W(save))
  1164. X       bit_destroy(W(save));
  1165. X   if (W(snarf))
  1166. X      free(W(snarf));
  1167. X   if (W(bitmap))
  1168. X      free(W(bitmap));
  1169. X   zap_cliplist(win);
  1170. X
  1171. X   for(i=0; i< MAXEVENTS;i++) 
  1172. X       if (W(events)[i])
  1173. X          free(W(events)[i]);
  1174. X
  1175. X   for(i=0; i< MAXMENU;i++) 
  1176. X      if (W(menus)[i])
  1177. X         menu_destroy(W(menus)[i]);
  1178. X
  1179. X   free(win);
  1180. X   }
  1181. X
  1182. X/* unlink an alternate window from list */
  1183. X
  1184. Xint
  1185. Xdetach(win2)
  1186. XWINDOW *win2;
  1187. X   {
  1188. X   register WINDOW *win = win2;
  1189. X
  1190. X   if (!(W(main)))
  1191. X      return;
  1192. X   for(win=win2->main;W(alt)!=win2;win=W(alt))
  1193. X      ;
  1194. X   W(alt)= win2->alt;
  1195. X   }
  1196. X
  1197. X/* notify alternate windows of impending death */
  1198. X
  1199. Xset_dead(win)
  1200. Xregister WINDOW *win;
  1201. X   {
  1202. X   for(win = W(alt); win != (WINDOW *) 0; win = W(alt)) {
  1203. X#ifdef DEBUG
  1204. X      dprintf(d)(stderr,"%s: telling %d\r\n",W(tty),W(num));
  1205. X#endif
  1206. X      W(main) = (WINDOW *) 0;
  1207. X      }
  1208. X   }
  1209. END_OF_FILE
  1210. # end of 'src/destroy.c'
  1211. fi
  1212. if test -f 'src/font_subs.c' -a "${1}" != "-c" ; then 
  1213.   echo shar: Will not clobber existing file \"'src/font_subs.c'\"
  1214. else
  1215. echo shar: Extracting \"'src/font_subs.c'\" \(4187 characters\)
  1216. sed "s/^X//" >'src/font_subs.c' <<'END_OF_FILE'
  1217. X/*                        Copyright (c) 1987 Bellcore
  1218. X *                            All Rights Reserved
  1219. X *       Permission is granted to copy or use this program, EXCEPT that it
  1220. X *       may not be sold for profit, the copyright notice must be reproduced
  1221. X *       on copies, and credit should be given to Bellcore where it is due.
  1222. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  1223. X */
  1224. X/*    $Header: font_subs.c,v 4.2 88/06/24 10:18:04 sau Exp $
  1225. X    $Source: /tmp/mgrsrc/src/RCS/font_subs.c,v $
  1226. X*/
  1227. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/RCS/font_subs.c,v $$Revision: 4.2 $";
  1228. X
  1229. X/* font routines */
  1230. X
  1231. X#include "bitmap.h"
  1232. X#include "font.h"
  1233. X#include "default_font.h"
  1234. X#include "window.h"
  1235. X#include <stdio.h>
  1236. X#ifdef DEBUG
  1237. X#   include "defs.h"
  1238. X#endif
  1239. X
  1240. X#define HEAD(x)        font->head.x
  1241. X
  1242. X/**************************************************************************
  1243. X *
  1244. X *    set up a font file
  1245. X */
  1246. X
  1247. Xstruct font *
  1248. Xopen_font(file)
  1249. Xchar *file;            /* name of font file */
  1250. X   {
  1251. X   FILE *fp;
  1252. X   int size;
  1253. X   char *malloc();
  1254. X   struct font *font, *open_sfont();
  1255. X
  1256. X   if (file == (char *) 0 || *file == '\0') {
  1257. X      return(open_sfont(default_font_head,&default_font));
  1258. X      }
  1259. X
  1260. X#ifdef DEBUG
  1261. X      dprintf(f)(stderr,"Opening font file [%s]\n",file);
  1262. X#endif
  1263. X
  1264. X   if ((fp=fopen(file,"r"))  == NULL)
  1265. X      return((struct font *)0);
  1266. X
  1267. X   if ((font=(struct font *) malloc(sizeof(struct font))) == (struct font *)0) {
  1268. X      fclose(fp);
  1269. X      return((struct font *)0);
  1270. X      }
  1271. X
  1272. X   if (fread(&(font->head),HEADER_SIZE,1,fp) != 1) {
  1273. X      free((char *) font);
  1274. X      fclose(fp);
  1275. X      return((struct font *)0);
  1276. X      }
  1277. X
  1278. X   if (HEAD(type) != FONT_A) {
  1279. X      free((char *) font);
  1280. X      fclose(fp);
  1281. X      return((struct font *)0);
  1282. X      }
  1283. X                               
  1284. X   font->data = bit_alloc(HEAD(wide) *HEAD(count),HEAD(high),NULL_DATA,1);
  1285. X   font->table = (struct entry **) 0;
  1286. X
  1287. X   /* read in font data */
  1288. X
  1289. X   size = BIT_SIZE(font->data);
  1290. X   fread(BIT_DATA(font->data), size, 1, fp);
  1291. X
  1292. X   /* create individual characters */
  1293. X
  1294. X   glyph_create( font );
  1295. X
  1296. X   fclose(fp);
  1297. X   return(font);
  1298. X   }
  1299. X
  1300. X
  1301. X/**************************************************************************
  1302. X *
  1303. X *    deallocate a font
  1304. X */
  1305. X
  1306. Xint
  1307. Xfree_font(dead_font)
  1308. Xstruct font *dead_font;        /* font to be deallocated */
  1309. X   {
  1310. X   register int i;
  1311. X
  1312. X   if (!dead_font)
  1313. X      return(-1);
  1314. X
  1315. X   for(i=0;i<MAXGLYPHS;i++)
  1316. X      if (dead_font->glyph[i])
  1317. X         bit_destroy(dead_font->glyph[i]);
  1318. X   if (dead_font->head.type != FONT_S)
  1319. X      bit_destroy(dead_font->data);
  1320. X   zap_fhash(dead_font);        /* free up hash table space */
  1321. X   i=font_purge(dead_font);    /* eliminate references to dead font */
  1322. X
  1323. X#ifdef DEBUG
  1324. X      dprintf(f)(stderr,"freeing font %d (%d references)\n",
  1325. X      dead_font->ident,i);
  1326. X#endif
  1327. X
  1328. X   free((char *) dead_font);
  1329. X   }
  1330. X
  1331. X/**************************************************************************
  1332. X *
  1333. X *    set up a static font file
  1334. X */
  1335. X
  1336. Xstruct font *
  1337. Xopen_sfont(head,data)
  1338. Xstruct font_header head;    /* font header */
  1339. XBITMAP *data;        /* array of bits */
  1340. X   {
  1341. X   char *malloc();
  1342. X   struct font *font;
  1343. X
  1344. X   if ((font=(struct font *) malloc(sizeof(struct font))) == (struct font *)0)
  1345. X      return((struct font *)0);
  1346. X
  1347. X   font->head = head;
  1348. X   font->data = data;
  1349. X   font->head.type = FONT_S;
  1350. X   font->table = (struct entry **) 0;
  1351. X
  1352. X   /* create individual characters */
  1353. X
  1354. X   glyph_create( font );
  1355. X
  1356. X   return(font);
  1357. X   }
  1358. X
  1359. X
  1360. Xstatic
  1361. Xglyph_create( font )
  1362. Xstruct font *font;
  1363. X   {
  1364. X   register int i, x;
  1365. X   int        first = HEAD(start);
  1366. X   int        last = HEAD(start) + HEAD(count);
  1367. X   int        wide = HEAD(wide);
  1368. X   int        high = HEAD(high);
  1369. X   int        nochar;
  1370. X   
  1371. X   /* Pick the character to be printed for characters not in the set.
  1372. X      Normally, it is the character specified by C_NOCHAR, but it that isn't
  1373. X      in the range of the set, we pick the first character (which is usually
  1374. X      a space).
  1375. X   */
  1376. X   nochar = C_NOCHAR - HEAD(start);
  1377. X   if( nochar >= last )
  1378. X    nochar = 0;
  1379. X   nochar *= wide;
  1380. X
  1381. X   x = 0;
  1382. X   for(i=0; i<MAXGLYPHS; i++)
  1383. X      if (i < first || i >= last)
  1384. X         font->glyph[i] = bit_create(font->data, nochar, 0, wide, high);
  1385. X      else {
  1386. X         font->glyph[i] = bit_create(font->data, x, 0, wide, high);
  1387. X         x += wide;
  1388. X         }
  1389. X   }
  1390. END_OF_FILE
  1391. # end of 'src/font_subs.c'
  1392. fi
  1393. if test -f 'src/oblit/bitmap.c' -a "${1}" != "-c" ; then 
  1394.   echo shar: Will not clobber existing file \"'src/oblit/bitmap.c'\"
  1395. else
  1396. echo shar: Extracting \"'src/oblit/bitmap.c'\" \(4634 characters\)
  1397. sed "s/^X//" >'src/oblit/bitmap.c' <<'END_OF_FILE'
  1398. X/*                        Copyright (c) 1987 Bellcore
  1399. X *                            All Rights Reserved
  1400. X *       Permission is granted to copy or use this program, EXCEPT that it
  1401. X *       may not be sold for profit, the copyright notice must be reproduced
  1402. X *       on copies, and credit should be given to Bellcore where it is due.
  1403. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  1404. X */
  1405. X/*    $Header: bitmap.c,v 4.2 88/07/07 09:08:51 sau Exp $
  1406. X    $Source: /tmp/mgrsrc/src/oblit/RCS/bitmap.c,v $
  1407. X*/
  1408. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/oblit/RCS/bitmap.c,v $$Revision: 4.2 $";
  1409. X
  1410. X/*  SUN-2  and SUN-3 bitblit code */
  1411. X
  1412. X#ifdef sun
  1413. X#  include <sys/ioctl.h>
  1414. X#  include <sun/fbio.h>
  1415. X#  include <sys/file.h>
  1416. X#  include <sys/mman.h>
  1417. X#endif
  1418. X#include <stdio.h>
  1419. X#include "bitmap.h"
  1420. X
  1421. Xint bit_debug = 1;
  1422. Xstatic int _s_start;
  1423. Xstatic _s_len;
  1424. X
  1425. X/* open the screen; it looks like memory */
  1426. X
  1427. XBITMAP *
  1428. Xbit_open(name)
  1429. Xchar *name;            /* name of frame buffer */
  1430. X{
  1431. X   BITMAP *result = BIT_NULL;
  1432. X#ifdef sun
  1433. X   int fd;
  1434. X   char *malloc();
  1435. X   register DATA addr;
  1436. X   struct fbtype buff;
  1437. X   int pagesize;
  1438. X
  1439. X   Bprintf(1) ("bit_open:(%s)\n", name);
  1440. X
  1441. X   /* open the SUN screen */
  1442. X
  1443. X   if ((fd = open(name, O_RDWR)) < 0)
  1444. X      return (BIT_NULL);
  1445. X
  1446. X   /* get the frame buffer size */
  1447. X
  1448. X   if (ioctl(fd, FBIOGTYPE, &buff) < 0)
  1449. X      return (BIT_NULL);
  1450. X
  1451. X   /* malloc space for frame buffer */
  1452. X
  1453. X   pagesize = getpagesize();
  1454. X   if ((_s_start = (int) malloc(buff.fb_size + pagesize)) == 0)
  1455. X      return (BIT_NULL);
  1456. X
  1457. X   /* align space on a page boundary */
  1458. X
  1459. X   buff.fb_size = (buff.fb_size+pagesize-1) &~ (pagesize-1);
  1460. X   addr = (DATA ) ((_s_start + pagesize - 1) & ~(pagesize - 1));
  1461. X
  1462. X   /* map the frame buffer into malloc'd space */
  1463. X
  1464. X#ifdef _MAP_NEW      /* New semantics for mmap in Sun release 4.0 */
  1465. X   addr = (DATA) mmap(addr, _s_len=buff.fb_size,
  1466. X                   PROT_WRITE, _MAP_NEW|MAP_SHARED, fd, 0);
  1467. X   if ((int)addr == -1)
  1468. X      return (BIT_NULL);
  1469. X#else
  1470. X   if (mmap(addr, _s_len = buff.fb_size, PROT_WRITE, MAP_SHARED, fd, 0) < 0)
  1471. X      return (BIT_NULL);
  1472. X#endif
  1473. X
  1474. X   if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  1475. X      return (BIT_NULL);
  1476. X
  1477. X   result->primary = result;
  1478. X   result->data = addr;
  1479. X   result->x0 = 0,
  1480. X      result->y0 = 0,
  1481. X      result->wide = buff.fb_width;
  1482. X   result->high = buff.fb_height;
  1483. X   result->type = _SCREEN;
  1484. X   Bprintf(2) ("  O.K.(0x%lx)\n (%d x %x)",
  1485. X           (long) result->data, result->wide, result->high);
  1486. X#endif
  1487. X   return (result);
  1488. X}
  1489. X
  1490. X/* destroy a bitmap, free up space */
  1491. X
  1492. Xint
  1493. Xbit_destroy(bitmap)
  1494. XBITMAP *bitmap;
  1495. X{
  1496. X   Bprintf(1) ("bit_destroy:\n");
  1497. X   if (bitmap == (BITMAP *) 0)
  1498. X      return (-1);
  1499. X   if (IS_MEMORY(bitmap) && IS_PRIMARY(bitmap))
  1500. X      free(bitmap->data);
  1501. X   else if (IS_SCREEN(bitmap) && IS_PRIMARY(bitmap)) {
  1502. X      munmap(BIT_DATA(bitmap), _s_len);
  1503. X      free(_s_start);
  1504. X   }
  1505. X   free(bitmap);
  1506. X   return (0);
  1507. X}
  1508. X
  1509. X/* create a bitmap as a sub-rectangle of another bitmap */
  1510. X
  1511. XBITMAP *
  1512. Xbit_create(map, x, y, wide, high)
  1513. XBITMAP *map;
  1514. Xint x, y, wide, high;
  1515. X{
  1516. X   char *malloc();
  1517. X   register BITMAP *result;
  1518. X
  1519. X   Bprintf(1) ("bit_create:\n");
  1520. X   if (x + wide > map->wide)
  1521. X      wide = map->wide - x;
  1522. X   if (y + high > map->high)
  1523. X      high = map->high - y;
  1524. X   if (wide < 1 || high < 1)
  1525. X      return (BIT_NULL);
  1526. X
  1527. X   if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  1528. X      return (BIT_NULL);
  1529. X
  1530. X   result->data = map->data;
  1531. X   result->x0 = map->x0 + x;
  1532. X   result->y0 = map->y0 + y;
  1533. X   result->wide = wide;
  1534. X   result->high = high;
  1535. X   result->primary = map->primary;
  1536. X   result->type = map->type;
  1537. X   Bprintf(2) ("  Created %d,%d %d,%d\n", result->x0, result->y0,
  1538. X           result->wide, result->high);
  1539. X   return (result);
  1540. X}
  1541. X
  1542. X/* allocate space for, and create a memory bitmap */
  1543. X
  1544. XBITMAP *
  1545. Xbit_alloc(wide, high, data, bits)
  1546. Xunsigned short wide, high;
  1547. XDATA data;
  1548. Xint bits;    /* in preparation for color */
  1549. X{
  1550. X   char *malloc();
  1551. X   register BITMAP *result;
  1552. X   register int size;
  1553. X
  1554. X   Bprintf(1) ("bit_alloc:\n");
  1555. X   if ((result = (BITMAP *) malloc(sizeof(BITMAP))) == (BITMAP *) 0)
  1556. X      return (result);
  1557. X
  1558. X   result->x0 = 0;
  1559. X   result->y0 = 0;
  1560. X   result->high = high;
  1561. X   result->wide = wide;
  1562. X
  1563. X   size = BIT_SIZE(result);
  1564. X
  1565. X   if (data != (DATA ) 0)
  1566. X      result->data = data;
  1567. X#ifdef ALIGN32
  1568. X   else if ((result->data = (DATA ) memalign(4,size)) == (DATA ) 0) {
  1569. X#else
  1570. X   else if ((result->data = (DATA ) malloc(size)) == (DATA ) 0) {
  1571. X#endif
  1572. X      free(result);
  1573. X      return ((BITMAP *) 0);
  1574. X   }
  1575. X
  1576. X   result->primary = result;
  1577. X   result->type = _MEMORY;
  1578. X   Bprintf(2) ("  Created %d,%d %d,%d\n", result->x0, result->y0,
  1579. X           result->wide, result->high);
  1580. X   return (result);
  1581. X}
  1582. END_OF_FILE
  1583. # end of 'src/oblit/bitmap.c'
  1584. fi
  1585. if test -f 'src/print.c' -a "${1}" != "-c" ; then 
  1586.   echo shar: Will not clobber existing file \"'src/print.c'\"
  1587. else
  1588. echo shar: Extracting \"'src/print.c'\" \(4315 characters\)
  1589. sed "s/^X//" >'src/print.c' <<'END_OF_FILE'
  1590. X/*                        Copyright (c) 1987 Bellcore
  1591. X *                            All Rights Reserved
  1592. X *       Permission is granted to copy or use this program, EXCEPT that it
  1593. X *       may not be sold for profit, the copyright notice must be reproduced
  1594. X *       on copies, and credit should be given to Bellcore where it is due.
  1595. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  1596. X */
  1597. X/*    $Header: print.c,v 4.1 88/06/21 13:34:25 bianchi Exp $
  1598. X    $Source: /tmp/mgrsrc/src/RCS/print.c,v $
  1599. X*/
  1600. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/RCS/print.c,v $$Revision: 4.1 $";
  1601. X
  1602. X/* debugging routines for printing status info */
  1603. X
  1604. X#include <stdio.h>
  1605. X
  1606. Xstatic char *flags[] = { 
  1607. X   "active",
  1608. X   "escape",
  1609. X   "snarfable",
  1610. X   "reverse",
  1611. X   "standout",
  1612. X   "died",
  1613. X   "expose",
  1614. X   "background",
  1615. X   "nokill",
  1616. X   "vi",
  1617. X   "downloading",
  1618. X   "noinput",
  1619. X   "nowrap",
  1620. X   "overstrike",
  1621. X   "abs-coords",
  1622. X   "minus",
  1623. X   "snarf-lines",
  1624. X   "snarf-tabs",
  1625. X   "snarf-hard",
  1626. X   (char *) 0
  1627. X   };
  1628. X
  1629. Xstatic char *events[] = {
  1630. X   "1_up",
  1631. X   "no-event",
  1632. X   "2_up",
  1633. X   "3_up",
  1634. X   "no-event",
  1635. X   "3_down",
  1636. X   "2_down",
  1637. X   "no-event",
  1638. X   "1_down",
  1639. X   "shape",
  1640. X   "redraw",
  1641. X   "activated",
  1642. X   "deactivated",
  1643. X   "covered",
  1644. X   "uncovered",
  1645. X   "moved",
  1646. X   "destroyed",
  1647. X   "accept",
  1648. X   "notify",
  1649. X   "tell-me",
  1650. X   "snarfed",
  1651. X   "paste",
  1652. X   "stack",
  1653. X   "stack_flag",
  1654. X   (char *) 0
  1655. X   };
  1656. X
  1657. Xstatic char *stack[] = {
  1658. X   "menu",
  1659. X   "event",
  1660. X   "font",
  1661. X   "cursor",
  1662. X   "bitmap",
  1663. X   "position",
  1664. X   "window",
  1665. X   "flags",
  1666. X   "mouse",
  1667. X   "text",
  1668. X   "CLEAR",
  1669. X   (char *) 0
  1670. X   };
  1671. X
  1672. Xstatic char *menu_states[] = {
  1673. X    "choice",
  1674. X    "bottom",
  1675. X    "top",
  1676. X    "top & bottom",
  1677. X    "left",
  1678. X    "left & bottom",
  1679. X    "left & top",
  1680. X    "left & top & bottom",
  1681. X    "right",
  1682. X    "right & bottom",
  1683. X    "right & top",
  1684. X    "right & top & bottom",
  1685. X    "right & left",
  1686. X    "right & left & bottom",
  1687. X    "right & left & top",
  1688. X    "right & left & top & bottom",
  1689. X   };
  1690. X
  1691. Xstatic char buff[512];
  1692. X
  1693. X/* get flag names */
  1694. X
  1695. Xchar *print_flags(n)
  1696. Xint n;
  1697. X   {
  1698. X   char *binary();
  1699. X   register int i,j;
  1700. X
  1701. X   sprintf(buff,"(%s)",binary(n));
  1702. X   for(j=1,i=0;flags[i];i++,j<<=1)
  1703. X      if (j&n) {
  1704. X         if (*buff) strcat(buff,",");
  1705. X         strcat(buff,flags[i]);
  1706. X         }
  1707. X   return(buff);
  1708. X   }
  1709. X
  1710. X/* get menu states */
  1711. X
  1712. Xchar
  1713. X*print_menu(n)
  1714. Xint n;        /* menu state */
  1715. X   {
  1716. X   return(menu_states[n%16]);
  1717. X   }
  1718. X
  1719. X/* get stack codes */
  1720. X
  1721. Xchar *print_stack(n)
  1722. Xint n;
  1723. X   {
  1724. X   register int i,j;
  1725. X   char *binary();
  1726. X
  1727. X   sprintf(buff,"(%s)",binary(n));
  1728. X   for(j=1,i=0;stack[i];i++,j<<=1)
  1729. X      if (j&n) {
  1730. X         if (*buff) strcat(buff,",");
  1731. X         strcat(buff,stack[i]);
  1732. X         }
  1733. X   return(buff);
  1734. X   }
  1735. X
  1736. X/* get event names */
  1737. X
  1738. Xchar *print_events(n)
  1739. Xint n;
  1740. X   {
  1741. X   register int i,j;
  1742. X   char *binary();
  1743. X
  1744. X   sprintf(buff,"(%s)",binary(n));
  1745. X   for(j=1,i=0;events[i];i++,j<<=1)
  1746. X      if (j&n) {
  1747. X         if (*buff) strcat(buff,",");
  1748. X         strcat(buff,events[i]);
  1749. X         }
  1750. X   return(buff);
  1751. X   }
  1752. X
  1753. X
  1754. X/* get ps info */
  1755. X
  1756. Xstatic char *list[100];
  1757. Xstatic int p_count = 0;
  1758. X
  1759. Xint
  1760. Xget_ps()
  1761. X   {
  1762. X   FILE *popen(), *ps = popen("ps a","r");
  1763. X   char line[81];
  1764. X   char *index(), *save_line();
  1765. X
  1766. X   fgets(line,sizeof(line),ps);
  1767. X   while(fgets(line,sizeof(line),ps) != NULL) {
  1768. X      list[p_count++] = save_line(line+6);
  1769. X      }
  1770. X   pclose(ps);
  1771. X   return(p_count);
  1772. X   }
  1773. X
  1774. Xint
  1775. Xfree_ps()
  1776. X   {
  1777. X   register int i;
  1778. X
  1779. X   for(i=0;i<p_count;i++) {
  1780. X      if (list[i])
  1781. X         free(list[i]);
  1782. X      }
  1783. X   p_count = 0;
  1784. X   }
  1785. X
  1786. Xchar *
  1787. Xprint_ps(tty)
  1788. Xchar *tty;
  1789. X   {
  1790. X   register int i;
  1791. X   register char *check = tty + (strlen(tty) - 2);
  1792. X   register char *p1,*p2;
  1793. X   char *index(), *strcpy();
  1794. X
  1795. X   *buff = '\0';
  1796. X   for(i=0;i<p_count;i++)
  1797. X      if (list[i] && strncmp(check,list[i],2)==0 &&
  1798. X                     (int)(p1 = index(list[i],':')+4)>4) {
  1799. X         if (p2 = index(p1,'\n'))
  1800. X            *p2 = '\0';
  1801. X         strcpy(buff,p1);
  1802. X         if (*p1 != '-')
  1803. X            break;
  1804. X         }
  1805. X   return(buff ? buff : strcpy(buff,"?? unknown ??"));
  1806. X   } 
  1807. X
  1808. X/*****************************************************************************
  1809. X *    print x in binary
  1810. X */
  1811. X
  1812. Xchar *
  1813. Xbinary(x)
  1814. Xint x;
  1815. X   {
  1816. X   register int i;
  1817. X   static char out[33];
  1818. X   int n=32;
  1819. X
  1820. X   out[n+1] = '\0';
  1821. X   for(i=0;i<n+1;i++)
  1822. X      if (x&(1<<i))
  1823. X         out[n-i] = '1';
  1824. X      else
  1825. X         out[n-i] = '0';
  1826. X   for(i=0;out[i]=='0' && i<33;i++);
  1827. X   return(i>0?out+i-1:out);
  1828. X   }
  1829. END_OF_FILE
  1830. # end of 'src/print.c'
  1831. fi
  1832. if test -f 'src/win_make.c' -a "${1}" != "-c" ; then 
  1833.   echo shar: Will not clobber existing file \"'src/win_make.c'\"
  1834. else
  1835. echo shar: Extracting \"'src/win_make.c'\" \(4132 characters\)
  1836. sed "s/^X//" >'src/win_make.c' <<'END_OF_FILE'
  1837. X/*                        Copyright (c) 1987 Bellcore
  1838. X *                            All Rights Reserved
  1839. X *       Permission is granted to copy or use this program, EXCEPT that it
  1840. X *       may not be sold for profit, the copyright notice must be reproduced
  1841. X *       on copies, and credit should be given to Bellcore where it is due.
  1842. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  1843. X */
  1844. X/*    $Header: win_make.c,v 4.1 88/06/21 13:34:54 bianchi Exp $
  1845. X    $Source: /tmp/mgrsrc/src/RCS/win_make.c,v $
  1846. X*/
  1847. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/RCS/win_make.c,v $$Revision: 4.1 $";
  1848. X
  1849. X/* make an alternate window */
  1850. X
  1851. X#include "bitmap.h"
  1852. X#include "font.h"
  1853. X#include "defs.h"
  1854. X#include "window.h"
  1855. X#include "event.h"
  1856. X#include <stdio.h>
  1857. X
  1858. X/* manipulte an alternate (client) window - called by put_window() */
  1859. X
  1860. Xint
  1861. Xwin_make(win,indx)
  1862. XWINDOW *win;            /* window issuing make-call */
  1863. Xint indx;            /* current index into char string (yuk!) */
  1864. X   {
  1865. X   register int *p = W(esc);    /* array of ESC digits */
  1866. X   int buff[10];
  1867. X   WINDOW *win2=win, *insert_win();
  1868. X
  1869. X   switch (W(esc_cnt)) {
  1870. X      case 1:            /*  destroy the window */
  1871. X#ifdef DEBUG
  1872. X         dprintf(N)(stderr,"%s: destroying %d\n",W(tty),p[0]);
  1873. X#endif
  1874. X         if (p[0]<=0 || W(main)->alt == (WINDOW *) 0 ||
  1875. X                  W(main)->alt->num<p[0]) {
  1876. X            break;
  1877. X            }
  1878. X         for (win = W(main)->alt;win!=(WINDOW *) 0; win=W(alt))  {
  1879. X            if (W(num)==p[0])
  1880. X               break;
  1881. X            }
  1882. X         if (win != (WINDOW *) 0) 
  1883. X            W(flags) |= W_DIED;
  1884. X         break;
  1885. X
  1886. X      case 0:        /* goto a new window */
  1887. X         if (W(num)==p[0] || W(main)->alt == (WINDOW *) 0 ||
  1888. X                  W(main)->alt->num<p[0]) {
  1889. X            break;
  1890. X            }
  1891. X         for (win = W(main);win!=(WINDOW *) 0; win=W(alt))  {
  1892. X            if (W(num)==p[0])
  1893. X               break;
  1894. X            }
  1895. X
  1896. X         /* move contents of shell buffer to new window */
  1897. X
  1898. X         if (win != (WINDOW *) 0) {
  1899. X            W(from_fd) = W(to_fd);
  1900. X            win2->from_fd = 0;
  1901. X            W(max) = win2->max - win2->current - indx - 1;
  1902. X            bcopy(win2->buff + win2->current + indx + 1,W(buff),W(max));
  1903. X            W(current) = 0;
  1904. X#ifdef DEBUG
  1905. X            dprintf(N)(stderr,"%s: xfer %d\r\n",W(tty),W(max));
  1906. X#endif
  1907. X            }
  1908. X         break;
  1909. X
  1910. X      case 3:        /* make a new window */
  1911. X         p[4] = -1;
  1912. X         /* no break */
  1913. X      case 4:        /* new window + font (not implemented) */
  1914. X#ifdef DEBUG
  1915. X         dprintf(N)(stderr,"%s: making alternate window\n",W(tty));
  1916. X#endif
  1917. X         if (check_window(p[0],p[1],p[2],p[3],p[4]) == 0 ||
  1918. X                 next_window >= MAXWIN) {
  1919. X            write(ACTIVE(to_fd),"\n",1);
  1920. X            break;
  1921. X            }
  1922. X         if (win!=active)
  1923. X            cursor_off();
  1924. X         ACTIVE_OFF();
  1925. X         if ((active = insert_win((WINDOW *) 0)) == (WINDOW *) 0 ||
  1926. X                     !setup_window(active,font,p[0],p[1],p[2],p[3])) {
  1927. X            fprintf(stderr,"Out of memory for window creation -- bye!\n");
  1928. X            quit();
  1929. X            }
  1930. X
  1931. X         /* next_window++;  (this needs more thought) */
  1932. X
  1933. X         /* make the window */
  1934. X
  1935. X         set_covered(active);
  1936. X         border(active,BLK_BDR,WH_BDR);
  1937. X         CLEAR(ACTIVE(window),BIT_CLR);
  1938. X         ACTIVE_ON();
  1939. X         cursor_on();
  1940. X
  1941. X#ifdef DEBUG
  1942. X         dprintf(N)(stderr,"%s: window created\n",W(tty));
  1943. X#endif
  1944. X         /* fix pointer chain */
  1945. X
  1946. X         ACTIVE(to_fd) =  W(to_fd);
  1947. X         ACTIVE(main) = W(main);
  1948. X         ACTIVE(pid) =  W(pid);
  1949. X         ACTIVE(setid) =  W(setid);
  1950. X         strcpy(ACTIVE(tty),ACTIVE(main)->tty);
  1951. X         ACTIVE(from_fd) = 0;
  1952. X         ACTIVE(alt) =  W(main)->alt;
  1953. X         ACTIVE(main)->alt = active;
  1954. X         if (ACTIVE(alt))
  1955. X            ACTIVE(num) = ACTIVE(alt)->num + 1;
  1956. X         else
  1957. X            ACTIVE(num) = 1;
  1958. X         
  1959. X#ifdef DEBUG
  1960. X         dprintf(N)(stderr,"%s: created num %d\r\n",ACTIVE(tty),ACTIVE(num));
  1961. X#endif
  1962. X         sprintf(buff,"%d\n",ACTIVE(num));
  1963. X         write(ACTIVE(to_fd),buff,strlen(buff));
  1964. X         clip_bad(active);    /* invalidate clip lists */
  1965. X         break;
  1966. X      case 5:        /* nothing */
  1967. X         break;
  1968. X     }
  1969. X   }
  1970. END_OF_FILE
  1971. # end of 'src/win_make.c'
  1972. fi
  1973. echo shar: End of archive 20 \(of 61\).
  1974. cp /dev/null ark20isdone
  1975. MISSING=""
  1976. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  1977.     21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 \
  1978.     38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 \
  1979.     55 56 57 58 59 60 61 ; do
  1980.     if test ! -f ark${I}isdone ; then
  1981.     MISSING="${MISSING} ${I}"
  1982.     fi
  1983. done
  1984. if test "${MISSING}" = "" ; then
  1985.     echo You have unpacked all 61 archives.
  1986.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1987. else
  1988.     echo You still need to unpack the following archives:
  1989.     echo "        " ${MISSING}
  1990. fi
  1991. ##  End of shell archive.
  1992. exit 0
  1993.