home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume17 / mgr / part61 < prev    next >
Encoding:
Internet Message Format  |  1989-01-19  |  46.7 KB
  1. Subject:  v17i062:  MGR, Bellcore window manager, Part61/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 62
  7. Archive-name: mgr/part61
  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 61 (of 61)."
  19. # Contents:  src/put_window.c
  20. # Wrapped by rsalz@papaya.bbn.com on Thu Nov 17 21:06:09 1988
  21. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  22. if test -f 'src/put_window.c' -a "${1}" != "-c" ; then 
  23.   echo shar: Will not clobber existing file \"'src/put_window.c'\"
  24. else
  25. echo shar: Extracting \"'src/put_window.c'\" \(44878 characters\)
  26. sed "s/^X//" >'src/put_window.c' <<'END_OF_FILE'
  27. X/*                        Copyright (c) 1987 Bellcore
  28. X *                            All Rights Reserved
  29. X *       Permission is granted to copy or use this program, EXCEPT that it
  30. X *       may not be sold for profit, the copyright notice must be reproduced
  31. X *       on copies, and credit should be given to Bellcore where it is due.
  32. X *       BELLCORE MAKES NO WARRANTY AND ACCEPTS NO LIABILITY FOR THIS PROGRAM.
  33. X */
  34. X/*    $Header: put_window.c,v 4.4 88/08/16 07:25:54 sau Exp $
  35. X    $Source: /tmp/mgrsrc/src/RCS/put_window.c,v $
  36. X*/
  37. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/src/RCS/put_window.c,v $$Revision: 4.4 $";
  38. X
  39. X/* Very simple terminal emulator (this is an old comment) */
  40. X
  41. X#include <sys/time.h>        /* experimental */
  42. X#include "bitmap.h"
  43. X#include "font.h"
  44. X#include "defs.h"
  45. X#include "menu.h"
  46. X#include "event.h"
  47. X#include <stdio.h>
  48. X#include "window.h"
  49. X#include "clip.h"
  50. X
  51. X/* macros for putting a character on a window */
  52. X
  53. X#define DO_CHAR(font,c) \
  54. X    ((font)->glyph[c])
  55. X    
  56. X#ifdef COLOR
  57. X#define PUT_CHAR(dest,x,y,font,op,c)   \
  58. X   bit_blit(dest,x,y-fsizehigh,fsizewide,fsizehigh, \
  59. X   BIT_SRC | (W(background)&~NOCOLOR),BIT_NULL,0,0), \
  60. X   bit_blit(dest,x,y-fsizehigh,fsizewide,fsizehigh, \
  61. X   (op & NOCOLOR)^BIT_DST | (op ^ W(background))&~NOCOLOR, \
  62. X   DO_CHAR(font,c),0,0)
  63. X
  64. X/* fix the border color */
  65. X
  66. X#define BORDER(win) \
  67. X   ((win==active) ? border(win,SUM_BDR-1,1) : border(win,BLK_BDR,WH_BDR))
  68. X
  69. X#else NOCOLOR
  70. X
  71. X#define PUT_CHAR(dest,x,y,font,op,c)    \
  72. X    bit_blit(dest,x,y-fsizehigh,fsizewide,fsizehigh, \
  73. X    op,DO_CHAR(font,c),0,0)
  74. X#define BORDER(win)
  75. X
  76. X#endif
  77. X#define Abs(x)               ((x)>0?(x):-(x))
  78. X
  79. X/* flseep is experimental */
  80. X
  81. X#define fsleep() \
  82. X   { \
  83. X   struct timeval time; \
  84. X   time.tv_sec = 0; \
  85. X   time.tv_usec = 330000; \
  86. X   select(0,0,0,0,&time); \
  87. X   }
  88. X
  89. Xrect clip;                /* clipping rectangle */
  90. X
  91. X/* send a string to a window, interpret ESC's
  92. X * return # of chars actually processed
  93. X */
  94. X
  95. Xint
  96. Xput_window(win,buff,buff_count)
  97. Xregister WINDOW *win;                    /* window to update */
  98. Xregister char *buff;                    /* ptr to update text */
  99. Xint buff_count;                        /* # of characters */
  100. X   {
  101. X   register BITMAP *window;            /* bitmap to update */
  102. X   register BITMAP *text = (BITMAP *) 0;    /* current text region */
  103. X   register int indx;                /* index into buff */
  104. X   register int cnt;                /* # of esc. numbers */
  105. X   register char c;                /* current char */
  106. X   register int done=0;                /* set to 1 to exit */
  107. X   int bell=0;                    /* 1 if screen flashed once */
  108. X   int sub_window = 0;                /* sub window created */
  109. X   int fsizehigh, fsizewide;            /* variables to save deref. */
  110. X   struct font *Get_font();    
  111. X   char *malloc(), *binary();
  112. X   struct menu_state *do_menu();
  113. X   char *trans();
  114. X
  115. X   /* set up environment */
  116. X
  117. X   if (W(flags)&W_ACTIVE) {
  118. X      window = W(window);
  119. X      }
  120. X   else {
  121. X      window = bit_create(W(save),SUM_BDR,SUM_BDR,
  122. X                          BIT_WIDE(W(window)),BIT_HIGH(W(window)));
  123. X      sub_window++;
  124. X      }
  125. X
  126. X   if (window==(BITMAP *) 0) {        /* never! */
  127. X      perror("Bit_create failed for window");
  128. X      return(0);
  129. X      }
  130. X
  131. X   /* avoid repeated dereferencing of pointers */
  132. X
  133. X   fsizehigh = FSIZE(high);
  134. X   fsizewide = FSIZE(wide);
  135. X
  136. X   if (Do_clip()) {
  137. X      Set_clipall();
  138. X      Set_cliplow(W(x)+W(text).x,W(y)+W(text).y-fsizehigh);
  139. X      }
  140. X
  141. X   if (W(text.wide))
  142. X      text = bit_create(window,W(text.x),W(text.y),W(text.wide),W(text.high)); 
  143. X   if (text == (BITMAP *) 0)
  144. X      text = window;
  145. X
  146. X   if (W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)) {
  147. X      MOUSE_OFF(mousex,mousey);
  148. X      }
  149. X
  150. X   if (win==active)
  151. X      cursor_off();
  152. X
  153. X   /* do each character */
  154. X
  155. X   for(indx=0;c= *buff++, indx<buff_count && !done; indx++)
  156. X   switch (W(flags)&W_STATE) {
  157. X
  158. X      /* download and process text strings */
  159. X
  160. X   case W_TEXT:                /* down load a text string */
  161. X      cnt = W(esc_cnt);
  162. X         W(snarf[W(esc)[TEXT_COUNT]++]) = c;
  163. X      if (W(esc)[TEXT_COUNT] >= W(esc)[cnt]) {
  164. X         W(snarf)[W(esc)[TEXT_COUNT]] = '\0';
  165. X         W(flags) &= ~W_TEXT;
  166. X         if (W(snarf) && W(code)!=T_BITMAP && W(code)!=T_GRUNCH)
  167. X            (void) trans(W(snarf));
  168. X         down_load(win,window,text);
  169. X         done++;
  170. X         }
  171. X      break;
  172. X
  173. X   /**********************************************************************
  174. X    *    Handle escape codes 
  175. X    */
  176. X
  177. X   case W_ESCAPE:            /* process an escape code */
  178. X      W(flags) &= ~(W_ESCAPE);
  179. X      cnt = W(esc_cnt);
  180. X      switch(c&=0177) {
  181. X         case ESC :             /* turn on escape mode */
  182. X                    W(flags) |= W_ESCAPE;
  183. X                    W(esc_cnt) = 0;
  184. X                    W(esc[0]) = 0;
  185. X                    break;
  186. X
  187. X         case '0': case '1': case '2': case '3': case '4':
  188. X         case '5': case '6': case '7': case '8': case '9':
  189. X               W(esc)[W(esc_cnt)] = W(esc)[W(esc_cnt)]*10 + c-'0'; 
  190. X               W(flags) |= W_ESCAPE;
  191. X               if (W(flags)&W_MINUS && W(esc)[W(esc_cnt)] > 0) {
  192. X                  W(esc)[W(esc_cnt)] = -(W(esc)[W(esc_cnt)]);
  193. X                  W(flags) &= ~(W_MINUS);
  194. X                  }
  195. X               break;
  196. X
  197. X         case E_SEP1:            /* primary field separator */
  198. X         case E_SEP2:            /* secondary field separator */
  199. X               if (W(esc_cnt)+1 < MAXESC)
  200. X                   W(esc_cnt)++;
  201. X               W(esc)[W(esc_cnt)] = 0;
  202. X               W(flags) &= ~(W_MINUS);
  203. X               W(flags) |= W_ESCAPE;
  204. X               break;
  205. X
  206. X         case E_MINUS:          /* set the MINUS flag */
  207. X               W(flags) |= (W_ESCAPE|W_MINUS);
  208. X               break;
  209. X
  210. X         case E_NULL:            /* do nothing */
  211. X               done++;
  212. X               break;
  213. X
  214. X         case E_ADDLINE:          /* add a new line */
  215. X               if (*W(esc)) {
  216. X                  register int count = *W(esc);
  217. X                  scroll(win,text,W(y)-fsizehigh,T_HIGH,- count*(fsizehigh),
  218. X                      W(background));
  219. X                  }
  220. X               else {
  221. X                  scroll(win,text,W(y)-fsizehigh,T_HIGH,-(fsizehigh),
  222. X                      W(background));
  223. X                  bit_blit(text,0,HIGH-fsizehigh,T_WIDE,
  224. X                      fsizehigh,W(background),NULL_DATA,0,0);
  225. X                  }
  226. X               done++;
  227. X               break;
  228. X
  229. X         case E_ADDCHAR:          /* insert a character */
  230. X               {
  231. X               register int wide = fsizewide*(*W(esc)?*W(esc):1);
  232. X               if (wide+W(x)>T_WIDE)
  233. X                  wide = T_WIDE-W(x);
  234. X               bit_blit(text,W(x)+wide,W(y)-fsizehigh,
  235. X                        T_WIDE-W(x)-wide, fsizehigh,BIT_SRC,
  236. X                        text,W(x),W(y)-fsizehigh);
  237. X               bit_blit(text,W(x),W(y)-fsizehigh,wide,
  238. X                    fsizehigh,W(background),0,0,0);
  239. X               }
  240. X               break;
  241. X
  242. X         case E_DELETELINE:          /* delete a line */
  243. X               if (*W(esc)) {
  244. X                  register int count = *W(esc);
  245. X                  scroll(win,text,W(y)-fsizehigh,T_HIGH,count*fsizehigh,
  246. X                      W(background));
  247. X                  }
  248. X               else {
  249. X                  scroll(win,text,W(y)-fsizehigh,T_HIGH,fsizehigh,
  250. X                      W(background));
  251. X                  }
  252. X               done++;
  253. X               break;
  254. X
  255. X         case E_DELETECHAR:          /* delete a character */
  256. X               {
  257. X               register int wide = fsizewide*(*W(esc)?*W(esc):1);
  258. X               if (wide+W(x)>T_WIDE)
  259. X                  wide = T_WIDE-W(x);
  260. X               bit_blit(text,W(x),W(y)-fsizehigh,
  261. X                        T_WIDE-W(x)-wide, fsizehigh,BIT_SRC,
  262. X                        text,W(x)+wide,W(y)-fsizehigh);
  263. X               bit_blit(text,T_WIDE-wide,W(y)-fsizehigh,wide,
  264. X                    fsizehigh,W(background),0,0,0);
  265. X               }
  266. X               break;
  267. X
  268. X         case E_UPLINE:          /* up 1 line */
  269. X#ifdef FRACCHAR
  270. X               if (cnt>0) {    /* move up fractions of a character line */
  271. X                  int div = W(esc)[1] == 0 ? 1 : W(esc)[1];
  272. X                  int n = W(esc)[0] * fsizehigh / div;
  273. X                  if (W(y)>n) {
  274. X                     W(y) -= n;
  275. X                     if (Do_clip())
  276. X                        Set_cliplow(10000,W(y)+W(text).y-fsizehigh);
  277. X                     }
  278. X                  break;
  279. X                  }
  280. X#endif
  281. X               if (W(y)>fsizehigh) W(y) -= fsizehigh;
  282. X               if (Do_clip())
  283. X                  Set_cliplow(10000,W(y)+W(text).y-fsizehigh);
  284. X               break;
  285. X
  286. X         case E_RIGHT:          /* right 1 line */
  287. X#ifdef FRACCHAR                
  288. X               if (cnt>0) {    /* move right/left a fraction of a character */
  289. X                  int div = W(esc)[1] == 0 ? 1 : W(esc)[1];
  290. X                  int n = W(esc)[0] * fsizewide / div;
  291. X                  W(x) += n;
  292. X                  if (W(x) < 0)
  293. X                     W(x) = 0;
  294. X                  break;
  295. X                  }
  296. X#endif
  297. X               W(x) += fsizewide;
  298. X               break;
  299. X
  300. X         case E_DOWN:            /* down 1 line */
  301. X#ifdef FRACCHAR
  302. X               if (cnt>0) {    /* move down a fraction of a character */
  303. X                  int div = W(esc)[1] == 0 ? 1 : W(esc)[1];
  304. X                  int n = W(esc)[0] * fsizehigh / div;
  305. X                        if (W(y)+n > T_HIGH) {
  306. X                            scroll(win,text,0,T_HIGH,n,W(background));
  307. X                            done++;
  308. X                            }
  309. X                  else {
  310. X                            W(y) += n;
  311. X                            if (Do_clip())
  312. X                                Set_cliphigh(0,W(y)+W(text).y);
  313. X                     }
  314. X                  break;
  315. X                  }
  316. X#endif
  317. X               if (W(y)+fsizehigh > T_HIGH) {
  318. X                  scroll(win,text,0,T_HIGH,fsizehigh,W(background));
  319. X                  done++;
  320. X                  }
  321. X               else {
  322. X                  W(y) += fsizehigh;
  323. X                  if (Do_clip())
  324. X                     Set_cliphigh(0,W(y)+W(text).y);
  325. X                  }
  326. X               break;
  327. X
  328. X         case E_FCOLOR:       /* set forground color */
  329. X               W(style) = (W(style)&NOCOLOR) | GETCOLOR(*W(esc));
  330. X               BORDER(win);
  331. X               break;
  332. X
  333. X         case E_BCOLOR:       /* set background color */
  334. X               W(background) = (W(background)&NOCOLOR) | GETCOLOR(*W(esc));
  335. X               BORDER(win);
  336. X               break;
  337. X
  338. X         case E_STANDOUT:        /* inverse video (characters) */
  339. X           standout( win );
  340. X               break;
  341. X
  342. X         case E_STANDEND:        /* normal video (characters) */
  343. X           standend( win );
  344. X               break;
  345. X
  346. X         case E_CLEAREOL:          /* clear to end of line */
  347. X               bit_blit(text,W(x),W(y)-fsizehigh,T_WIDE-W(x),
  348. X                    fsizehigh,W(background),0,0,0);
  349. X               if (Do_clip())
  350. X                  Set_cliphigh(BIT_WIDE(W(window)),0);
  351. X               break;
  352. X
  353. X         case E_CLEAREOS:          /* clear to end of window */
  354. X               bit_blit(text,W(x),W(y)-fsizehigh,T_WIDE-W(x),
  355. X                    fsizehigh,W(background),0,0,0);
  356. X               bit_blit(text,0,W(y),T_WIDE,T_HIGH-W(y),W(background),0,0,0);
  357. X               if (Do_clip())
  358. X                  Set_cliphigh(BIT_WIDE(W(window)),BIT_HIGH(window));
  359. X               break;
  360. X
  361. X         case E_SETCURSOR:            /* set the character cursor */
  362. X                    W(curs_type) = *W(esc);
  363. X                    break;
  364. X         case E_BLEEP:            /* highlight a section of the screen */
  365. X               if (cnt>2) {
  366. X                  register int *p = W(esc);
  367. X                  if (p[0]<0 || p[1]<0 )
  368. X                     break;
  369. X                  p[2] = BETWEEN(1,p[2],BIT_WIDE(screen)-1);
  370. X                  p[3] = BETWEEN(1,p[3],BIT_WIDE(screen)-1);
  371. X                  bit_blit(screen,p[0],p[1],p[2],p[3],BIT_NOT(BIT_DST),NULL_DATA,0,0);
  372. X                  fsleep();
  373. X                  bit_blit(screen,p[0],p[1],p[2],p[3],BIT_NOT(BIT_DST),NULL_DATA,0,0);
  374. X                  done++;
  375. X                  }
  376. X               break;
  377. X
  378. X         case E_FONT:              /* pick a new font */
  379. X#ifdef CUT
  380. X               W(flags) &= ~W_SNARFABLE;
  381. X#endif
  382. X               if (cnt > 0) {
  383. X                  W(esc)[TEXT_COUNT] = 0;
  384. X                  if (W(esc)[cnt]>0 && (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0)
  385. X                     W(flags) |= W_TEXT;
  386. X                  W(code) = T_FONT;
  387. X                  break;
  388. X                  }
  389. X
  390. X                  {
  391. X                  int font_count = W(esc)[cnt];
  392. X                  int baseline = FSIZE(baseline);
  393. X
  394. X                  W(font)=Get_font(font_count);
  395. X          fsizehigh = FSIZE(high);
  396. X          fsizewide = FSIZE(wide);
  397. X                  W(y) += FSIZE(baseline)-baseline;
  398. X                  if (W(y) < fsizehigh) {
  399. X                     scroll(win,text,W(y)-fsizehigh,T_HIGH,
  400. X                            W(y)-fsizehigh,W(background));
  401. X                     W(y)=fsizehigh;
  402. X                     done++;
  403. X                     }
  404. X                  }
  405. X               break;
  406. X
  407. X         case E_MOUSE:          /* testing  -- move the mouse */
  408. X               MOUSE_OFF(mousex,mousey);
  409. X               if (W(esc_cnt) < 1) {
  410. X                  mousex = W(x0) + W(x);
  411. X                  mousey = W(y0) + W(y);
  412. X                  }
  413. X               else {
  414. X                  mousex = W(esc)[cnt-1];
  415. X                  mousey = W(esc)[cnt];
  416. X                  mousex = BETWEEN(0,mousex,BIT_WIDE(screen)-1);
  417. X                  mousey = BETWEEN(0,mousey,BIT_HIGH(screen)-1);
  418. X                  }
  419. X               if (!(W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)))
  420. X                  MOUSE_ON(mousex,mousey);
  421. X               break;
  422. X
  423. X         case E_SIZE:              /* reshape window: cols, rows */
  424. X               if (!W(flags)&W_ACTIVE) break;
  425. X               if (cnt >= 1) {
  426. X                  int cols = W(esc)[cnt-1];
  427. X                  int lines = W(esc)[cnt];
  428. X                  int x = W(x0), y = W(y0);
  429. X
  430. X                  MOUSE_OFF(mousex,mousey);
  431. X
  432. X                  if (cnt>=3) {
  433. X                     x = W(esc)[0];
  434. X                     y = W(esc)[1];
  435. X                     }
  436. X
  437. X                  if (win!=active)
  438. X                     cursor_off();
  439. X                  ACTIVE_OFF();
  440. X                  expose(win);
  441. X                  shape(x, y,
  442. X                        cols?cols*fsizewide+2*SUM_BDR:
  443. X                             2*SUM_BDR + WIDE,
  444. X                        lines?lines*fsizehigh+2*SUM_BDR:
  445. X                             2*SUM_BDR + HIGH);
  446. X                  ACTIVE_ON();
  447. X                  if (!(W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)))
  448. X                     MOUSE_ON(mousex,mousey);
  449. X                  done++;
  450. X                  }
  451. X               break;
  452. X
  453. X         case E_PUTSNARF:          /* put the snarf buffer */
  454. X               if (snarf)
  455. X                  Write(W(to_fd),snarf,strlen(snarf));
  456. X#ifdef DEBUG
  457. X               dprintf(y)(stderr,"%s: sending yank buffer [%s]\n",W(tty),
  458. X                         snarf?snarf:"EMPTY");
  459. X#endif
  460. X               break;
  461. X
  462. X         case E_GIMME:          /* snarf text into input queue */
  463. X               W(esc)[TEXT_COUNT] = 0;
  464. X               if (W(esc)[cnt]>0 && W(esc)[cnt]<MAXSHELL &&
  465. X                          (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0)
  466. X                  W(flags) |= W_TEXT;
  467. X               W(code) = T_GIMME;
  468. X               break;
  469. X
  470. X         case E_GMAP:          /* read a bitmap from a file */
  471. X#ifdef DEBUG
  472. X              dprintf(*)(stderr,"%s: fetching bitmap %d\r\n",
  473. X                               W(tty),*W(esc)-1);
  474. X#endif
  475. X               W(esc)[TEXT_COUNT] = 0;
  476. X               if (W(esc)[cnt]>0 && W(esc)[cnt]<MAX_PATH &&
  477. X                          (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0)
  478. X                  W(flags) |= W_TEXT;
  479. X               W(code) = T_GMAP;
  480. X               break;
  481. X
  482. X         case E_SMAP:          /* save a bitmap on a file */
  483. X               W(esc)[TEXT_COUNT] = 0;
  484. X               if (W(esc)[cnt]>0 && W(esc)[cnt]<MAX_PATH &&
  485. X                          (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0) {
  486. X                  W(flags) |= W_TEXT;
  487. X#ifdef DEBUG
  488. X                  dprintf(*)(stderr,"%s: saving bitmap %d\r\n",
  489. X                               W(tty),*W(esc)-1);
  490. X#endif
  491. X                  }
  492. X               W(code) = T_SMAP;
  493. X               break;
  494. X
  495. X         case E_SNARF:          /* snarf text into the snarf buffer */
  496. X               W(esc)[TEXT_COUNT] = 0;
  497. X               if (W(esc)[cnt]>=0 &&    /*** was just > */
  498. X                          (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0)
  499. X                  W(flags) |= W_TEXT;
  500. X               W(code) = T_YANK;
  501. X               break;
  502. X
  503. X         case E_STRING:          /* write text into the offscreen bitmap */
  504. X               W(esc)[TEXT_COUNT] = 0;
  505. X               if (W(esc)[cnt]>0 && /* W(bitmaps)[*W(esc)-1] && */
  506. X                          (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0)
  507. X                  W(flags) |= W_TEXT;
  508. X               W(code) = T_STRING;
  509. X               break;
  510. X
  511. X         case E_GRUNCH:          /* graphics scrunch mode  (experimental) */
  512. X               W(esc)[TEXT_COUNT] = 0;
  513. X               if (W(esc)[cnt]>=0 &&    /*** was just > */
  514. X                          (W(snarf)=malloc(W(esc)[cnt]+1)) != (char *)0)
  515. X                  W(flags) |= W_TEXT;
  516. X               W(code) = T_GRUNCH;
  517. X               break;
  518. X
  519. X#ifdef XMENU
  520. X         case E_XMENU:              /* extended menu stuff */
  521. X                                        /* ^[3X    remove menu 3 from window */
  522. X                                        /* ^[3,4X    select item 4 of menu 3 */
  523. X                                        /* ^[1,2,3X    display menu 3 at 1,2 */
  524. X                                        /* ^[1,2,3,4Xhighlight menu 3 item 4 at 1,2 */
  525. X               {
  526. X               register int *p = W(esc);
  527. X               register struct menu_state *menu;
  528. X               switch(cnt) {
  529. X                  case 0:            /* remove menu from display */
  530. X                     if (p[0]>=0 && p[0]<MAXMENU && (menu=W(menus[p[0]])))
  531. X                        menu_remove(menu);
  532. X                  case 1:            /* select active item */
  533. X                     if (p[0]>=0 && p[0]<MAXMENU && (menu=W(menus[p[0]])))
  534. X                        menu->current = p[1];
  535. X                     break;
  536. X                  case 2:            /* display menu  on window */
  537. X                     if (p[2]>=0 && p[2]<MAXMENU && (menu=W(menus[p[2]])))
  538. X                        menu_setup(menu,window,Scalex(p[0]),Scaley(p[1]),-1);
  539. X                     break;
  540. X                  case 3:            /* highlight menu item on window */
  541. X                     if (p[2]>=0 && p[2]<MAXMENU && 
  542. X                                   (menu=W(menus[p[2]])) && menu->menu) {
  543. X                        bit_blit(window, Scalex(p[0])+MENU_BORDER,
  544. X                                 Scaley(p[1])+(p[3]-1)*menu->bar_sizey+
  545. X                                 MENU_BORDER,
  546. X                               menu->bar_sizex, menu->bar_sizey,
  547. X                               BIT_NOT(BIT_DST), NULL_DATA, 0, 0);
  548. X                        }
  549. X                     break;
  550. X                     }
  551. X               }
  552. X               break;
  553. X#endif
  554. X         case E_MENU:              /* get a menu */
  555. X               {            /* should be split into several cases */
  556. X               register int b = (W(esc)[0]<0);        /* which button */
  557. X               register int n = Abs(W(esc)[0]);        /* menu number */
  558. X
  559. X               /* setup menu pointer */
  560. X
  561. X               if (cnt > 2) {
  562. X                  int parent = n;        /* parent menu # */
  563. X                  int child = W(esc[2]);    /* child menu number */
  564. X                  int item = W(esc[1]);        /* item # of parent */
  565. X                  int flags = W(esc[3]);    /* menu flags */
  566. X
  567. X                  if (parent<0 || parent >= MAXMENU || child >= MAXMENU ||
  568. X                      W(menus[parent])==(struct menu_state*)0)
  569. X                     break;
  570. X
  571. X#ifdef DEBUG
  572. X                  dprintf(M)(stderr,"Linking menu %d to parent %d at item %d\n",
  573. X                             child,parent,item);
  574. X#endif
  575. X
  576. X                  if (item<0)                    /* page link */
  577. X                     W(menus[parent])->next = child;
  578. X                  else if (item < W(menus[parent])->count)    /* slide lnk */
  579. X                     menu_setnext(W(menus[parent]),item) = child; 
  580. X
  581. X                  /* menu flags */
  582. X
  583. X                  if (flags > 0)
  584. X                     W(menus[parent])->flags = flags;
  585. X
  586. X                  break;
  587. X                  }
  588. X
  589. X               /* download a menu */
  590. X
  591. X               if (cnt > 0) {
  592. X                  W(esc)[TEXT_COUNT] = 0;
  593. X                  if (W(menus)[n]) {
  594. X                     menu_destroy(W(menus)[n]);
  595. X                     W(menus)[n] = (struct menu_state *) 0;
  596. X                     if (W(menu[0])== n)
  597. X                        W(menu[0]) = -1;
  598. X                     if (W(menu[1])== n)
  599. X                        W(menu[1]) = -1;
  600. X                     }
  601. X                  if (W(esc)[cnt]>0 && (W(snarf)=malloc(W(esc)[cnt]+1))
  602. X                                     != (char *)0) {
  603. X                     W(flags) |= W_TEXT;
  604. X                     W(code) = T_MENU;
  605. X                     }
  606. X#ifdef DEBUG
  607. X                  dprintf(M)(stderr,"downloading menu %d\n",n);
  608. X#endif
  609. X                  }
  610. X
  611. X               /* select menu number */
  612. X
  613. X               else if (n < MAXMENU && W(menus)[n]) {
  614. X                  int last_menu = W(menu[b]);  
  615. X
  616. X#ifdef DEBUG
  617. X                  dprintf(M)(stderr,"selecting menu %d on button %d\n",n,b);
  618. X#endif
  619. X                  W(menu[b]) = n;
  620. X                  if (last_menu<0 && button_state==(b?BUTTON_1:BUTTON_2))
  621. X                     go_menu(b);
  622. X                  }
  623. X               else
  624. X                  W(menu[b]) = -1;
  625. X               }
  626. X               break;
  627. X
  628. X         case E_EVENT:            /* get an event */
  629. X               switch(cnt) {
  630. X                  case 2:    /* append to an event */
  631. X                  case 1:    /* set an event */
  632. X                     W(esc)[TEXT_COUNT] = 0;
  633. X                     if (W(esc)[cnt]>0 && (W(snarf)=malloc(W(esc)[cnt]+1))
  634. X                                  != (char *)0) {
  635. X                        W(flags) |= W_TEXT;
  636. X                        W(code) = T_EVENT;
  637. X                        }
  638. X                     break;
  639. X                  case 0:
  640. X                    cnt = W(esc)[0];
  641. X            if( !CHK_EVENT(cnt) )
  642. X               break;
  643. X                    EVENT_CLEAR_MASK(win,cnt);
  644. X                    if (W(events)[GET_EVENT(cnt)]) {
  645. X                       free (W(events)[GET_EVENT(cnt)]);
  646. X                       W(events)[GET_EVENT(cnt)] = (char *) 0;
  647. X                      }
  648. X                    break;
  649. X                  }
  650. X               break;
  651. X
  652. X         case E_SEND:            /* send a message */
  653. X               W(esc)[TEXT_COUNT] = 0;
  654. X               if (W(esc)[cnt]>0 && (W(snarf)=malloc(W(esc)[cnt]+1))
  655. X                                  != (char *)0) {
  656. X                  W(flags) |= W_TEXT;
  657. X                  W(code) = T_SEND;
  658. X                  }
  659. X               break;
  660. X
  661. X         case E_BITGET:            /* upload a bitmap (temporary)*/
  662. X               {
  663. X               int offset = W(esc)[2];
  664. X               int which = *W(esc);
  665. X               int size = W(esc)[1];
  666. X               BITMAP *m = W(bitmaps)[which-1];
  667. X
  668. X               if (cnt>1 && which>0 && which < MAXBITMAPS &&
  669. X                        m != (BITMAP *) 0 &&
  670. X                        size+offset<BIT_SIZE(m))
  671. X                  write(W(to_fd),BIT_DATA(m)+offset,size);
  672. X               }
  673. X               break;
  674. X         case E_BITCRT:          /* create/destroy a bitmap */
  675. X               switch(cnt) {
  676. X                  case 0:
  677. X                     if (W(esc)[0] && W(esc[0]<=MAXBITMAPS) &&
  678. X                                  W(bitmaps)[W(esc)[0]-1] != (BITMAP *) 0) {
  679. X                        bit_destroy(W(bitmaps)[W(esc)[0]-1]);
  680. X                        W(bitmaps)[W(esc)[0]-1] = (BITMAP *) 0;
  681. X#ifdef DEBUG
  682. X                        dprintf(B)(stderr,"%s: Destroyed bitmap %d\r\n",
  683. X                                  W(tty),*W(esc)-1);
  684. X#endif
  685. X                        }
  686. X                     break;
  687. X                  case 2:        /* create a new bitmap */
  688. X                     if (W(esc)[0] && W(esc[0]<=MAXBITMAPS) &&
  689. X                                  W(bitmaps)[W(esc)[0]-1] == (BITMAP *) 0) {
  690. X                        W(bitmaps)[W(esc)[0]-1] = 
  691. X                              bit_alloc(Scalex(W(esc)[1]),Scalex(W(esc)[2]),
  692. X                                        NULL_DATA,DEPTH);
  693. X#ifdef DEBUG
  694. X                        dprintf(B)(stderr,"%s: created bitmap %d (%d,%d)\r\n",
  695. X                                W(tty),*W(esc),W(esc)[1],W(esc)[2]);
  696. X#endif
  697. X                        }
  698. X                     break;
  699. X                  }
  700. X               break;
  701. X
  702. X         case E_BITLOAD:          /* download a bitmap */
  703. X               if (cnt >=2) {
  704. X                  W(esc)[TEXT_COUNT] = 0;
  705. X                  W(bitmap) = bit_alloc(W(esc[0]),W(esc[1]),NULL_DATA,DEPTH);
  706. X                  if (W(bitmap) != (BITMAP *) 0) {
  707. X                     W(flags) |= W_TEXT;
  708. X                     W(snarf) = (char *) BIT_DATA(W(bitmap));
  709. X                     }
  710. X                  W(code) = T_BITMAP;
  711. X                  }
  712. X               break;
  713. X
  714. X         case E_SHAPE:          /* reshape window, make it active */
  715. X
  716. X               MOUSE_OFF(mousex,mousey);
  717. X
  718. X               ACTIVE_OFF();
  719. X               if (win!=active) {
  720. X                  cursor_off();
  721. X                  expose(win);
  722. X                  }
  723. X               
  724. X               if (cnt >= 3)
  725. X                  shape(W(esc)[cnt-3], W(esc)[cnt-2],
  726. X                        W(esc)[cnt-1], W(esc)[cnt]);
  727. X               else if (cnt == 1)
  728. X                  shape(W(esc)[cnt-1], W(esc)[cnt],
  729. X                        BIT_WIDE(W(border)),
  730. X                        BIT_HIGH(W(border)));
  731. X
  732. X               ACTIVE_ON();
  733. X               if (!(W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)))
  734. X                  MOUSE_ON(mousex,mousey);
  735. X
  736. X               done++;
  737. X               break;
  738. X
  739. X         case E_BITBLT:         /* do a bit blit */
  740. X               win_rop(win,window);
  741. X               done++;
  742. X               break;
  743. X
  744. X         case E_CIRCLE:          /* Plot a circle (or ellipse) */
  745. X               circle_plot(win,window);
  746. X               break;
  747. X
  748. X         case E_LINE:              /* Plot a line */
  749. X               win_plot(win,window);
  750. X               break;
  751. X
  752. X         case E_GO:              /* Go; move graphics pointer */
  753. X               win_go(win);
  754. X               break;
  755. X
  756. X         case E_MOVE:              /* move to x,y pixels */
  757. X#ifdef CUT
  758. X                  W(flags) &= ~W_SNARFABLE;
  759. X#endif
  760. X                  if (Do_clip())
  761. X                     Set_cliphigh(W(x)+W(text).x+fsizewide,W(y)+W(text).y);
  762. X          if (cnt>0) {
  763. X                     W(x) = Scalex(*W(esc));
  764. X                     W(y) = Scaley(W(esc)[1]);
  765. X                     }
  766. X                   else {
  767. X                     W(x) += Scalex(*W(esc));
  768. X                     }
  769. X                   if (W(x)+fsizewide > WIDE && !(W(flags)&W_NOWRAP))
  770. X                      W(x) = WIDE-fsizewide;
  771. X                   if (W(y) > HIGH)
  772. X                      W(y) = HIGH - fsizehigh;
  773. X                   if (Do_clip())
  774. X                      Set_cliplow(W(x)+W(text).x,W(y)+W(text).y-fsizehigh);
  775. X               break;
  776. X
  777. X         case E_CUP:              /* move to col,row (zero based) */
  778. X               if (cnt < 1) break;
  779. X                  {
  780. X                  register int x = W(esc)[cnt-1] * fsizewide;
  781. X                  register int y = W(esc)[cnt] * fsizehigh;
  782. X                  if (x == BETWEEN(-1,x,T_WIDE-fsizewide) &&
  783. X                      y == BETWEEN(-1,y,T_HIGH)) {
  784. X                      if (Do_clip())
  785. X                        Set_cliphigh(W(x)+W(text).x+fsizewide,W(y)+W(text).y);
  786. X                      W(y) = y+fsizehigh;
  787. X                      W(x) = x;
  788. X                      if (Do_clip())
  789. X                         Set_cliplow(W(x)+W(text).x,W(y)+W(text).y-fsizehigh);
  790. X                      }
  791. X                  }
  792. X               break;
  793. X
  794. X         case E_VI:              /* turn on vi hack */
  795. X               W(flags) |= W_VI;
  796. X               break;
  797. X
  798. X         case E_NOVI:              /* turn off vi hack */
  799. X               W(flags) &= ~W_VI;
  800. X               break;
  801. X
  802. X         case E_PUSH:            /* push environment */
  803. X              win_push(win,*W(esc));
  804. X              break;
  805. X
  806. X         case E_POP:            /* pop old environment */
  807. X              MOUSE_OFF(mousex,mousey);
  808. X              win_pop(win);
  809. X              if (!(W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)))
  810. X                 MOUSE_ON(mousex,mousey);
  811. X              done++;
  812. X              break;
  813. X
  814. X         case E_TEXTREGION:        /* setup text region */
  815. X              switch (cnt) {
  816. X                 case 1:    /* setup scrolling region (~aka vt100) */
  817. X                      if (W(esc)[0] >=0 && W(esc)[1] >= W(esc)[0] && 
  818. X                                  W(esc)[1]*fsizehigh < BIT_HIGH(W(window))) {
  819. X                         W(text.x) = 0;
  820. X                         W(text.wide) = BIT_WIDE(W(window));
  821. X                         W(text.y) = fsizehigh*W(esc[0]);
  822. X                         W(text.high) = fsizehigh*(1+W(esc[1])) - W(text.y);
  823. X                         if (W(y) < W(text.y)+fsizehigh)
  824. X                            W(y) = W(text.y) + fsizehigh;
  825. X                         if (W(y) > W(text.high))
  826. X                            W(y) = W(text.high);
  827. X                         }
  828. X                      break;
  829. X                 case 3:        /* set up entire region */
  830. X                      W(text.wide) = Scalex(W(esc[2]));
  831. X                      W(text.high) = Scaley(W(esc[3]));
  832. X                      W(text.x) = Scalex(W(esc[0]));
  833. X                      W(text.y) = Scaley(W(esc[1]));
  834. X                      if (W(text.high) >= fsizehigh*MIN_Y  &&
  835. X                                       W(text.wide) >= fsizewide*MIN_X) {
  836. X                         W(x) = 0;
  837. X                         W(y) = fsizehigh;
  838. X#ifdef CUT
  839. X                         W(flags) &= ~W_SNARFABLE;
  840. X#endif
  841. X                         break;
  842. X                         }
  843. X                      W(text.x) = 0;
  844. X                      W(text.y) = 0;
  845. X                      W(text.wide) = 0;
  846. X                      W(text.high) = 0;
  847. X                      break;
  848. X                 case 4:    /* set up entire region (use rows, cols) */
  849. X                      W(text.x) = W(esc[0]) * fsizewide;
  850. X                      W(text.y) = W(esc[1]) * fsizehigh;
  851. X                      W(text.wide) = W(esc[2]) * fsizewide;
  852. X                      W(text.high) = W(esc[3]) * fsizehigh;
  853. X                      if (W(text.high) >= fsizehigh*MIN_Y  &&
  854. X                                       W(text.wide) >= fsizewide*MIN_X) {
  855. X                          W(x) = 0;
  856. X                          W(y) = fsizehigh;
  857. X                          break;
  858. X                          }
  859. X                      break;
  860. X                 case 0:         /* clear text region */
  861. X#ifdef CUT
  862. X                      if (W(text.x)%fsizewide!= 0 || W(text.y)%fsizehigh!=0)
  863. X                         W(flags) &= ~W_SNARFABLE;
  864. X#endif
  865. X                      W(text.x) = 0;
  866. X                      W(text.y) = 0;
  867. X                      W(text.wide) = 0;
  868. X                      W(text.high) = 0;
  869. X                      break;
  870. X                 }
  871. X              done++;
  872. X              break;
  873. X
  874. X         case E_SETMODE:          /* set a window mode */
  875. X#ifdef DEBUG
  876. X              dprintf(E)(stderr,"%s: setting mode %d\r\n",W(tty),*W(esc));
  877. X#endif
  878. X              switch(W(esc)[0]) {
  879. X         case M_STANDOUT:
  880. X              standout(win);
  881. X              break;
  882. X                 case M_BACKGROUND:    /* enable background writes */
  883. X                      W(flags) |= W_BACKGROUND;
  884. X                      break;
  885. X                 case M_NOINPUT:    /* disable keyboard input */
  886. X                      W(flags) |= W_NOINPUT;
  887. X                      break;
  888. X                 case M_AUTOEXPOSE:    /* auto expose upon write */
  889. X                      W(flags) |= W_EXPOSE;
  890. X                      break;
  891. X                 case M_WOB:        /* set white on black */
  892. X                      if (W(flags)&W_REVERSE) 
  893. X                         break;
  894. X#ifdef COLOR
  895. X                      W(style) = W(style)&NOCOLOR |
  896. X                            (~W(style))&~NOCOLOR;
  897. X                      W(background) = W(background)&NOCOLOR |
  898. X                            (~W(background))&~NOCOLOR;
  899. X                      CLEAR(window,W(background));
  900. X                      BORDER(win);
  901. X#else
  902. X                      W(background) = BIT_SET;
  903. X                      W(flags)|= W_REVERSE;
  904. X                      if (W(flags)&W_OVER)
  905. X                         W(style) = ROP_INVERT(W(style));
  906. X                      else
  907. X                         W(style)= W(flags)&W_STANDOUT ?
  908. X                                          BIT_SRC : BIT_NOT(BIT_SRC);
  909. X                      CLEAR(window,BIT_NOT(BIT_DST));
  910. X#endif
  911. X                      if (Do_clip())
  912. X                         Set_all();
  913. X                      break;
  914. X                 case M_NOWRAP:      /* turn on no-wrap */
  915. X                      W(flags) |= W_NOWRAP;
  916. X                      break;
  917. X                 case M_OVERSTRIKE:    /* turn on overstrike */
  918. X                      W(style) = W(style)&~NOCOLOR | W(op)&NOCOLOR;
  919. X                      W(flags) |= W_OVER;
  920. X                      break;
  921. X                 case M_ABS:        /* set absolute coordinate mode */
  922. X                      W(flags) |= W_ABSCOORDS;
  923. X                      break;
  924. X                 case M_DUPKEY:        /* duplicate esc char from keyboard */
  925. X                      W(flags) |= W_DUPKEY;;
  926. X                      if (cnt > 0)
  927. X                         W(dup) = W(esc[1])&0xff;
  928. X                      else
  929. X                         W(dup) = DUP_CHAR;
  930. X                      break;
  931. X                 case M_NOBUCKEY:    /* set no buckey interpretation mode */
  932. X                      W(flags) |= W_NOBUCKEY;
  933. X                      break;
  934. X#ifndef NOSTACK
  935. X                 case M_STACK:        /* enable event stacking */
  936. X                      EVENT_SET_MASK(win,EVENT_STACK);
  937. X                      break;
  938. X#endif
  939. X
  940. X#ifdef CUT
  941. X                 case M_SNARFLINES:    /* only cut lines */
  942. X                      W(flags) |= W_SNARFLINES;
  943. X                      break;
  944. X                 case M_SNARFTABS:    /* change spaces to tabs */
  945. X                      W(flags) |= W_SNARFTABS;
  946. X                      break;
  947. X                 case M_SNARFHARD:    /* snarf even if errors */
  948. X                      W(flags) |= W_SNARFHARD;
  949. X                      break;
  950. X#endif
  951. X                 case M_ACTIVATE:    /* activate the window */
  952. X                      if (win == active) 
  953. X                          break;
  954. X                      
  955. X                      MOUSE_OFF(mousex,mousey);
  956. X
  957. X                      cursor_off();
  958. X                      ACTIVE_OFF();
  959. X                      expose(win);
  960. X                      ACTIVE_ON();
  961. X                      cursor_on();
  962. X                      done++;
  963. X
  964. X                      if (!(W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)))
  965. X                         MOUSE_ON(mousex,mousey);
  966. X                      break;
  967. X                      }
  968. X              break;
  969. X
  970. X         case E_CLEARMODE:          /* clear a window mode  */
  971. X#ifdef DEBUG
  972. X              dprintf(E)(stderr,"%s: clearing mode %d\r\n",W(tty),*W(esc));
  973. X#endif
  974. X              switch(W(esc)[0]) {
  975. X         case M_STANDOUT:
  976. X              standend(win);
  977. X              break;
  978. X                 case M_BACKGROUND:    /* don't permit background writes */
  979. X                      W(flags) &= ~W_BACKGROUND;
  980. X                      break;
  981. X                 case M_NOINPUT:    /* permit keyboard input */
  982. X                      W(flags) &= ~W_NOINPUT;
  983. X                      break;
  984. X                 case M_AUTOEXPOSE:    /* don't auto expose */
  985. X                      W(flags) &= ~W_EXPOSE;
  986. X                      break;
  987. X                 case M_WOB:        /* set black-on-white */
  988. X                      if (!(W(flags)&W_REVERSE)) 
  989. X                         break;
  990. X#ifdef COLOR
  991. X                      W(style) = W(style)&NOCOLOR |
  992. X                            (~W(style))&~NOCOLOR;
  993. X                      W(background) = W(background)&NOCOLOR |
  994. X                            (~W(background))&~NOCOLOR;
  995. X                      CLEAR(window,W(background));
  996. X                      BORDER(win);
  997. X#else
  998. X                      W(background) = BIT_CLR;
  999. X                      W(flags)&= ~W_REVERSE;
  1000. X                      if(W(flags)&W_OVER)
  1001. X                         W(style) = ROP_INVERT(W(style));
  1002. X                      else
  1003. X                         W(style)= W(flags)&W_STANDOUT ?
  1004. X                                BIT_NOT(BIT_SRC) : BIT_SRC;
  1005. X                      CLEAR(window,BIT_NOT(BIT_DST));
  1006. X#endif
  1007. X                      if (Do_clip())
  1008. X                         Set_all();
  1009. X                      break;
  1010. X                 case M_NOWRAP:      /* turn off no-wrap */
  1011. X                      W(flags) &= ~W_NOWRAP;
  1012. X                      break;
  1013. X                 case M_OVERSTRIKE:    /* turn off overstrike */
  1014. X                      if ( !(W(flags)&W_STANDOUT) ^ !(W(flags)&W_REVERSE))
  1015. X#ifdef COLOR
  1016. X                         W(style) = BIT_SRC | ~NOCOLOR & W(background);
  1017. X                      else
  1018. X                         W(style) = BIT_SRC | ~NOCOLOR & W(style);
  1019. X#else
  1020. X                         W(style) = BIT_NOT(BIT_SRC);
  1021. X                      else
  1022. X                         W(style) = BIT_SRC;
  1023. X#endif
  1024. X                      W(flags) &= ~W_OVER;
  1025. X                      break;
  1026. X                 case M_ABS:        /* set relative coordinate mode */
  1027. X                      W(flags) &= ~W_ABSCOORDS;
  1028. X                      break;
  1029. X                 case M_DUPKEY:        /* reset keyboard dup-ky mode */
  1030. X                      W(flags) &= ~W_DUPKEY;
  1031. X                      break;
  1032. X                 case M_NOBUCKEY:    /* reset no buckey interpretation mode
  1033. X                    */
  1034. X                      W(flags) &= ~W_NOBUCKEY;
  1035. X                      break;
  1036. X#ifndef NOSTACK
  1037. X                 case M_STACK:        /* enable event stacking */
  1038. X                      EVENT_CLEAR_MASK(win,EVENT_STACK);
  1039. X                      break;
  1040. X#endif
  1041. X#ifdef CUT
  1042. X                 case M_SNARFLINES:    /* only cut lines */
  1043. X                      W(flags) &= ~W_SNARFLINES;
  1044. X                      break;
  1045. X                 case M_SNARFTABS:    /* change spaces to tabs */
  1046. X                      W(flags) &= ~W_SNARFTABS;
  1047. X                      break;
  1048. X                 case M_SNARFHARD:    /* snarf even if errors */
  1049. X                      W(flags) &= ~W_SNARFHARD;
  1050. X                      break;
  1051. X#endif
  1052. X                 case M_ACTIVATE:    /* hide the window */
  1053. X                      if (!(W(flags)&W_ACTIVE) || next_window==1)
  1054. X                          break;
  1055. X                      MOUSE_OFF(mousex,mousey);
  1056. X                      if (win!=active)
  1057. X                         cursor_off();
  1058. X                      ACTIVE_OFF();
  1059. X                      hide(win);
  1060. X                      ACTIVE_ON();
  1061. X                      if (win!=active)
  1062. X                         cursor_on();
  1063. X                      if (!(W(flags)&W_ACTIVE && mousein(mousex,mousey,win,0)))
  1064. X                         MOUSE_ON(mousex,mousey);
  1065. X
  1066. X                      done++;
  1067. X                      break;
  1068. X                      }
  1069. X              break;
  1070. X
  1071. X         case E_GETINFO:          /* send window info back to shell */
  1072. X              get_info(win,window,text);
  1073. X              break;
  1074. X                    
  1075. X         case E_MAKEWIN:        /* make or goto a new window */
  1076. X              MOUSE_OFF(mousex,mousey);
  1077. X              win_make(win,indx);
  1078. X              done++;
  1079. X              break;
  1080. X
  1081. X         case E_HALFWIN:        /* make a 1/2 window */
  1082. X              {
  1083. X              register int *p = W(esc);
  1084. X              char *tty = NULL;
  1085. X              char *half_window();
  1086. X
  1087. X              if (cnt < 3 ||  cnt > 4)
  1088. X                 break;
  1089. X              MOUSE_OFF(mousex,mousey);
  1090. X              if (win!=active)
  1091. X                 cursor_off();
  1092. X              ACTIVE_OFF();
  1093. X
  1094. X              switch (cnt) {
  1095. X                 case 4:
  1096. X                    tty = half_window(p[0],p[1],p[2],p[3],p[4]);
  1097. X                    break; 
  1098. X                 case 3:
  1099. X                    tty = half_window(p[0],p[1],p[2],p[3],-1);
  1100. X                    break; 
  1101. X                 }
  1102. X              if (tty) {
  1103. X                 write(W(to_fd),tty,strlen(tty));
  1104. X                 ACTIVE_ON();
  1105. X                 }
  1106. X              if (win!=active)
  1107. X                 cursor_on();
  1108. X              write(W(to_fd),"\r",1);
  1109. X              done++;
  1110. X              }
  1111. X              break;
  1112. X         case E_CURSOR:            /* set the mouse cursor */
  1113. X              {
  1114. X              BITMAP *map = W(bitmaps[*W(esc)]);
  1115. X              int x0=0,y0=0;
  1116. X
  1117. X              if (cnt > 0)
  1118. X                 x0 = W(esc[1]);
  1119. X              if (cnt > 0)
  1120. X                 y0 = W(esc[2]);
  1121. X
  1122. X              if (W(cursor)) {
  1123. X                 bit_destroy(W(cursor));
  1124. X                 W(cursor) = BIT_NULL;
  1125. X                 SETMOUSEICON(&mouse_arrow);
  1126. X                 }
  1127. X
  1128. X              if ( cursor_ok(map,x0,y0) && (W(cursor) = 
  1129. X                            bit_alloc(16,32,0,1)))
  1130. X                 bit_blit(W(cursor),0,0,16,32,BIT_SRC,map,x0,y0);
  1131. X              else
  1132. X                 W(cursor) = BIT_NULL;
  1133. X              }
  1134. X              break;
  1135. X
  1136. X         default:            /* not implemented */
  1137. X                    break;
  1138. X         }
  1139. X      if (!(W(flags)&W_ESCAPE))
  1140. X         W(flags) &= ~W_MINUS;
  1141. X      break;
  1142. X
  1143. X   /****************************************************************************
  1144. X    *    Normal characters
  1145. X    */
  1146. X
  1147. X   default:
  1148. X      switch(c&=0177) {
  1149. X         case ESC :             /* turn on escape mode */
  1150. X                    W(flags) |= W_ESCAPE;
  1151. X                    W(flags) &= ~(W_MINUS);
  1152. X                    W(esc_cnt) = 0;
  1153. X                    W(esc[0]) = 0;
  1154. X                    break;
  1155. X
  1156. X         case C_NULL:            /* null character -- ignore */
  1157. X                    break;
  1158. X
  1159. X         case C_BS:            /* back space */
  1160. X                    if (Do_clip()) {
  1161. X                       Set_cliphigh(W(x)+W(text).x + fsizewide,0);
  1162. X                       }
  1163. X                    W(x) -= fsizewide;
  1164. X                    if (W(x) < 0)
  1165. X                       W(x) = 0;
  1166. X                    if (Do_clip()) {
  1167. X                       Set_cliplow(W(x)+W(text).x,10000);
  1168. X                       }
  1169. X                    break;
  1170. X
  1171. X         case C_FF:            /* form feed */
  1172. X                    CLEAR(text,W(background));
  1173. X                    W(x)=0;
  1174. X                    W(y)=fsizehigh;
  1175. X#ifdef CUT
  1176. X                    W(flags) |= W_SNARFABLE;
  1177. X#endif
  1178. X                    if (Do_clip())
  1179. X                       Set_all();
  1180. X                    done++;
  1181. X                    break;
  1182. X
  1183. X         case C_BELL:            /* ring the bell  */
  1184. X                    bell_on();
  1185. X                    if (!bell++) {
  1186. X                       CLEAR(W(window),BIT_NOT(BIT_DST));
  1187. X                       CLEAR(W(window),BIT_NOT(BIT_DST));
  1188. X                       }
  1189. X                    break;
  1190. X
  1191. X         case C_TAB:            /* tab */
  1192. X                    W(x) = ((W(x)/fsizewide +8)& ~ 7) * fsizewide;
  1193. X                    if (W(x)+fsizewide >= T_WIDE) {
  1194. X                       W(x)=0;
  1195. X                       if (W(y)+fsizehigh > T_HIGH) {
  1196. X                          scroll(win,text,0,T_HIGH,fsizehigh,W(background));
  1197. X                          done++;
  1198. X                          }
  1199. X                       else
  1200. X                          W(y) += fsizehigh;
  1201. X                       }
  1202. X                    break;
  1203. X
  1204. X         case C_RETURN:            /* return */
  1205. X                    if (Do_clip()) {
  1206. X                       Set_cliphigh(W(x)+W(text).x + fsizewide,0);
  1207. X                       Set_cliplow(W(text).x,10000);
  1208. X                       }
  1209. X                    W(x)=0;
  1210. X                    break;
  1211. X
  1212. X         case C_NL:             /* line feed */
  1213. X                    if (W(y)+fsizehigh > T_HIGH) {
  1214. X                       scroll(win,text,0,T_HIGH,fsizehigh,W(background));
  1215. X                       done++;
  1216. X                       }
  1217. X                    else
  1218. X                       W(y) += fsizehigh;
  1219. X                    break;
  1220. X         default:            /* print a character */
  1221. X/*
  1222. X                    while (W(y) > T_HIGH) {
  1223. X                       W(y) -= fsizehigh;
  1224. X                       scroll(win,text,0,T_HIGH,fsizehigh,W(background));
  1225. X                       done++;
  1226. X                       }
  1227. X*/
  1228. X                    PUT_CHAR(text,W(x),W(y),W(font),W(style),c);
  1229. X
  1230. X                    W(x) += fsizewide;
  1231. X                    if (W(x)+fsizewide > T_WIDE && !(W(flags)&W_NOWRAP)) {
  1232. X                       if (Do_clip()) {
  1233. X                          Set_cliphigh(W(x)+W(text).x + fsizewide,0);
  1234. X                          Set_cliplow(W(text).x,10000);
  1235. X                          }
  1236. X                       W(x)=0;
  1237. X                       W(y) += fsizehigh;
  1238. X                       if (W(y) > T_HIGH) {
  1239. X                          W(y) -= fsizehigh;
  1240. X                          scroll(win,text,0,T_HIGH,fsizehigh,W(background));
  1241. X                          done++;
  1242. X                          }
  1243. X                       }
  1244. X                    break;
  1245. X         }
  1246. X      break;
  1247. X      }
  1248. X
  1249. X   if (Do_clip())
  1250. X      Set_cliphigh(W(x)+W(text).x+fsizewide,W(y)+W(text).y);
  1251. X
  1252. X   cursor_on();
  1253. X
  1254. X   MOUSE_ON(mousex,mousey);
  1255. X
  1256. X   if (text != window)        /* this is probably wrong */
  1257. X      bit_destroy(text);
  1258. X   if (sub_window) {
  1259. X      bit_destroy(window);
  1260. X      }
  1261. X
  1262. X   if (W(flags)&W_BACKGROUND && !(W(flags)&W_ACTIVE))
  1263. X      update(win, &clip);
  1264. X   return(indx);
  1265. X   }
  1266. X
  1267. X
  1268. Xstatic
  1269. Xstandout( win )
  1270. Xregister WINDOW *win;
  1271. X{
  1272. X    int    cnt;
  1273. X
  1274. X    if (W(flags)&W_STANDOUT)
  1275. X        return;
  1276. X#ifdef COLOR
  1277. X    cnt = W(style);
  1278. X    W(style) = W(background);
  1279. X    W(background) = cnt;
  1280. X#else
  1281. X
  1282. X    if (W(flags)&W_OVER) 
  1283. X        W(style) = ROP_INVERT(W(style));
  1284. X    else
  1285. X        W(style) = W(flags)&W_REVERSE ? BIT_SRC : BIT_NOT(BIT_SRC);
  1286. X#endif
  1287. X    W(flags) |= W_STANDOUT;
  1288. X}
  1289. X
  1290. X
  1291. Xstatic
  1292. Xstandend( win )
  1293. Xregister WINDOW *win;
  1294. X{
  1295. X    int    cnt;
  1296. X
  1297. X    if (!(W(flags)&W_STANDOUT))
  1298. X        return;
  1299. X#ifdef COLOR
  1300. X    cnt = W(style);
  1301. X    W(style) = W(background);
  1302. X    W(background) = cnt;
  1303. X#else
  1304. X
  1305. X    if (W(flags)&W_OVER) 
  1306. X        W(style) = ROP_INVERT(W(style));
  1307. X    else
  1308. X        W(style) = W(flags)&W_REVERSE ? BIT_NOT(BIT_SRC) : BIT_SRC;
  1309. X#endif
  1310. X    W(flags) &= ~ W_STANDOUT;
  1311. X}
  1312. END_OF_FILE
  1313. # end of 'src/put_window.c'
  1314. fi
  1315. echo shar: End of archive 61 \(of 61\).
  1316. cp /dev/null ark61isdone
  1317. MISSING=""
  1318. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  1319.     21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 \
  1320.     38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 \
  1321.     55 56 57 58 59 60 61 ; do
  1322.     if test ! -f ark${I}isdone ; then
  1323.     MISSING="${MISSING} ${I}"
  1324.     fi
  1325. done
  1326. if test "${MISSING}" = "" ; then
  1327.     echo You have unpacked all 61 archives.
  1328.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1329. else
  1330.     echo You still need to unpack the following archives:
  1331.     echo "        " ${MISSING}
  1332. fi
  1333. ##  End of shell archive.
  1334. exit 0
  1335.