home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume17 / mgr / part46 < prev    next >
Text File  |  1989-01-19  |  32KB  |  1,072 lines
  1. Subject:  v17i047:  MGR, Bellcore window manager, Part46/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 47
  7. Archive-name: mgr/part46
  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 46 (of 61)."
  19. # Contents:  demo/icon/zoom.c
  20. # Wrapped by rsalz@papaya.bbn.com on Thu Nov 17 21:05:55 1988
  21. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  22. if test -f 'demo/icon/zoom.c' -a "${1}" != "-c" ; then 
  23.   echo shar: Will not clobber existing file \"'demo/icon/zoom.c'\"
  24. else
  25. echo shar: Extracting \"'demo/icon/zoom.c'\" \(28993 characters\)
  26. sed "s/^X//" >'demo/icon/zoom.c' <<'END_OF_FILE'
  27. X/*                        Copyright (c) 1988 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: zoom.c,v 4.4 88/07/11 13:10:39 sau Exp $
  35. X    $Source: /tmp/mgrsrc/demo/icon/RCS/zoom.c,v $
  36. X*/
  37. Xstatic char    RCSid_[] = "$Source: /tmp/mgrsrc/demo/icon/RCS/zoom.c,v $$Revision: 4.4 $";
  38. X
  39. X/* icon edittor -- version I (single window) */
  40. X
  41. X#include <stdio.h>
  42. X#include <signal.h>
  43. X#include <sys/file.h>
  44. X#include "term.h"
  45. X#include "bitmap.h"
  46. X
  47. X/* general defines */
  48. X
  49. X#define GAP    2        /* general purpose gap */
  50. X#define TITLE    20        /* cols needed for title */
  51. X#define MAXMARK    7        /* max # of text items on status line */
  52. X#define MIN    4        /* min number of pixels in a bitmap */
  53. X#define SLEEP    5        /* time it takes for a message to go away */
  54. X#define SETMSG    1        /* set the message */
  55. X#define MAX    100        /* max # of pixels in a bitmap */
  56. X#define FILES    100        /* max # of files to edit at once */
  57. X
  58. X/* bitmap functions */
  59. X
  60. X#define SET    0        /* bit set */
  61. X#define CLEAR    1        /* clear */
  62. X#define TOGGLE    2        /* toggle */
  63. X#define ON    4        /* bit is on */
  64. X#define OFF    0        /* bit is off */
  65. X
  66. X/* zoom options */
  67. X
  68. X#define YANK    1        /* yank a region */
  69. X#define PUT    2        /* put a previously yanked region */
  70. X#define SHRINK    3        /* make icon smaller */
  71. X#define GROW    4        /* make icon bigger */
  72. X#define SHIFT    5
  73. X
  74. X/* title fields */
  75. X
  76. X#define T_FUNC    0        /* raster op functions */
  77. X#define T_OP    1        /* sweep otions */
  78. X#define T_SIZE    2        /* bitmap size */
  79. X#define T_NAME    3        /* file name */
  80. X
  81. X/* menu names */
  82. X
  83. X#define M_MODES        1    /* set/clear/toggle */
  84. X#define M_OPTIONS    2    /* yank/put/shrink/grow/ */
  85. X#define M_SIZE        3    /* none */
  86. X#define M_EDIT        4    /* save/get */
  87. X#define M_PUT        5    /* put functions */
  88. X#define M_FILES        6    /* name of files to edit */
  89. X
  90. X#define dprintf    if(debug)fprintf
  91. X
  92. X#define SET_FUNC(n) \
  93. X    (n!=func ? m_func(func = n) : n);
  94. X#define SWAP(x,y) \
  95. X    (code=x,x=y,y=code)
  96. X#define MARK(i) \
  97. X    ((i)>=0 ? marks[i] : 0)
  98. X
  99. X#ifndef Min
  100. X#define Min(x,y)    ((x)<(y)?(x):(y))
  101. X#endif
  102. X#ifndef Max
  103. X#define Max(x,y)    ((x)>(y)?(x):(y))
  104. X#endif
  105. X
  106. X#define INVERT(i) \
  107. X    m_bitwrite(x0+MARK(i-1),0,MARK(i)-MARK(i-1),font_high);
  108. X
  109. X#define W    BIT_WIDE
  110. X#define H    BIT_HIGH
  111. X
  112. X/* menus */
  113. X
  114. Xstruct menu_entry modes[] = {
  115. X   "set", "s0\r",
  116. X   "clear","s1\r",
  117. X   "toggle","s2\r",
  118. X   "grid","x\r",
  119. X   };
  120. X
  121. Xstruct menu_entry edit[] = {
  122. X   "save","f\r",
  123. X   "get","g\r",
  124. X   "yank","y\r",
  125. X   "quit","Q\r"
  126. X   };
  127. X
  128. Xstruct menu_entry resize[] = {
  129. X   "resize","+\r",
  130. X   };
  131. X
  132. Xstruct menu_entry options[] = {
  133. X   "yank","F1\r",
  134. X   "put","F2\r",
  135. X   "shrink","F3\r",
  136. X   "grow","F4\r",
  137. X   "shift","F5\r",
  138. X   "fix window","w\r",
  139. X   "undo","u\r",
  140. X   };
  141. X
  142. Xstruct menu_entry functions[] = {
  143. X   "copy","P0\r",
  144. X   "paint","P1\r",
  145. X   "mask","P2\r",
  146. X   "xor","P3\r",
  147. X   "grid","x\r",
  148. X   };
  149. X
  150. Xstruct menu_entry sizes[] = {
  151. X   "normal cursor","16,16",
  152. X   "small icon","48,48",
  153. X   "normal icon","64,64",
  154. X   };
  155. X
  156. Xstruct menu_entry files[FILES];
  157. X
  158. Xchar name[80];                /* name of icon */
  159. X
  160. X/* function codings for put */
  161. X
  162. Xint func_put[] = {
  163. X   BIT_SRC, BIT_SRC|BIT_DST, BIT_SRC&BIT_DST, BIT_SRC^BIT_DST
  164. X   };
  165. X
  166. Xint func_zoom[] = {
  167. X   BIT_SRC^BIT_DST, BIT_SRC&BIT_NOT(BIT_DST), BIT_DST&BIT_NOT(BIT_SRC), BIT_SRC
  168. X   };
  169. X   
  170. X
  171. Xint marks[MAXMARK];        /* positions demarcating labels */
  172. Xint win_wide, win_high;        /* window size */
  173. Xint win_x, win_y;        /* window location */
  174. Xint font_wide, font_high;    /* font size */
  175. Xint x0,y0;            /* starting location of icon*/
  176. Xint func;            /* current mgr raster function */
  177. Xint debug=0;
  178. Xchar *title[MAXMARK];        /* title goes here */
  179. Xint xmax,ymax,border;        /* screen parameters */
  180. Xchar *str_save(), *sprintf();
  181. Xchar *prog;
  182. X
  183. Xmain(argc,argv)
  184. Xint argc;
  185. Xchar **argv;
  186. X   {
  187. X
  188. X   register int i, c;
  189. X   int w, h;            /* bitmap size */
  190. X   int x,y;            /* scale factors */
  191. X   int mx,my;            /* mouse position */
  192. X   int bitx, bity;        /* bit position in bitmap */
  193. X   int lastx, lasty;        /* prev. bit position in bitmap */
  194. X   int size;            /* size of bitmap (bytes) */
  195. X   int done=0;            /* exit flag */
  196. X   int code;            /* return codes */
  197. X   int state;            /* bit toggle state */
  198. X 
  199. X   /* state flags */
  200. X
  201. X   int menu = -1;        /* current menu selected */
  202. X   int grid = 0;        /* grid state */
  203. X   int mode = TOGGLE;        /* edit mode */
  204. X   int function = 0;        /* function flag */
  205. X   int put = 0;            /* put mode */
  206. X
  207. X   /* misc */
  208. X
  209. X   int file_count;        /* number of files in file menu */
  210. X   char *pntr;            /* temp char pntr */
  211. X   char dims[12];        /* string buffer for icon dims */
  212. X   char line[512];        /* input buffer */
  213. X
  214. X   char *sprintf(), *malloc(), *rindex(), *get_str(), *strcpy();
  215. X   int clean(), message();
  216. X
  217. X   BITMAP *map;                /* what your editting */
  218. X   BITMAP *new, *temp;            /* temp bitmap */
  219. X   BITMAP *yanked=BIT_NULL;        /* yanked bitmap */
  220. X   BITMAP *last=BIT_NULL;        /* bitmap to undo */
  221. X   BITMAP *read_icon(), *set_undo();
  222. X
  223. X   ckmgrterm( *argv );
  224. X   debug = getenv("DEBUG");
  225. X
  226. X   if (argc <2) {
  227. X      fprintf(stderr,"Usage: %s files...\n",argv[0]);
  228. X      exit(1);
  229. X      }
  230. X   prog = *argv;
  231. X
  232. X   /* setup mgr */
  233. X
  234. X   m_setup(M_MODEOK);
  235. X   m_ttyset();
  236. X   m_push(P_FLAGS|P_MENU|P_EVENT);
  237. X
  238. X   signal(SIGINT,clean);
  239. X   signal(SIGTERM,clean);
  240. X   signal(SIGALRM,message);
  241. X
  242. X   m_setmode(M_ABS);
  243. X   m_setmode(M_NOWRAP);
  244. X   SET_FUNC(B_INVERT);
  245. X   get_font(&font_wide, &font_high);
  246. X   get_size(&win_x,&win_y,&win_wide,&win_high);
  247. X   get_param(0,&xmax,&ymax,&border);
  248. X
  249. X   menu_load(1,MENU_SIZE(modes),modes);
  250. X   menu_load(2,MENU_SIZE(options),options);
  251. X   menu_load(3,MENU_SIZE(resize),resize);
  252. X   menu_load(4,MENU_SIZE(edit),edit);
  253. X   menu_load(5,MENU_SIZE(functions),functions);
  254. X
  255. X   for(i=1;i<argc && i<= FILES-3;i++) {        /* save room for new names */
  256. X      pntr = rindex(argv[i],'/');
  257. X      pntr = pntr ? pntr++ : argv[i];
  258. X      files[i-1].value = str_save(pntr,"");
  259. X      files[i-1].action = str_save(argv[i],"\r");
  260. X      }
  261. X   file_count = i-1;
  262. X
  263. X   m_nomenu();
  264. X
  265. X   /* get mgr events */
  266. X
  267. X   m_setevent(BUTTON_1,"(%r)\r");
  268. X   m_setevent(BUTTON_2,"[%p]\r");
  269. X   m_setevent(BUTTON_2U,"$\r");
  270. X   m_setevent(RESHAPED,"S\r");
  271. X   m_setevent(REDRAW,"R\r");
  272. X   m_setevent(MOVE,"M\r");
  273. X   
  274. X   /* read in icon */ 
  275. X
  276. X   strcpy(name,argv[1]);
  277. X   if ((map = read_icon(argv[1],0))  == BIT_NULL) {
  278. X      pntr=get_str("Enter icon size (xxx,yyy):\n",
  279. X            win_wide/2,win_high/2,sizes,MENU_SIZE(sizes));
  280. X      sscanf(pntr,"%d,%d",&w,&h);
  281. X      if (w>MAX || h>MAX || w<MIN || h<MIN) {
  282. X         fprintf(stderr,"%s: Wrong size, try again\n",prog);
  283. X         clean(1);
  284. X         }
  285. X      map = bit_alloc(w,h,BIT_NULL,1);
  286. X      bit_blit(map,0,0,w,h,BIT_CLR,0,0,0);
  287. X      }
  288. X
  289. X   /* setup & display icon */
  290. X    
  291. X   x0 = 0;
  292. X   y0 = font_high + 2*GAP;
  293. X   get_scale(&x,&y,map);
  294. X
  295. X   m_clear();
  296. X   title[T_FUNC] = modes[mode].value;
  297. X   title[T_OP] = options[function].value;
  298. X   title[T_SIZE] = sprintf(dims,"%d x %d",W(map),H(map));
  299. X   title[T_NAME] = name;
  300. X   title[4] = NULL;
  301. X   Do_title(title);
  302. X
  303. X   zoom(map,x0,y0,x,y,SET);
  304. X
  305. X   /* process menu and mouse hits */
  306. X
  307. X   m_flush();
  308. X   while (!done && m_gets(line) != NULL) {
  309. X     dprintf(stderr,"main loop got: %s",line);
  310. X     menu = -1;
  311. X     m_nomenu();
  312. X     switch(c = *line) {
  313. X        case '[':                /* got button 1 hit */
  314. X           sscanf(line+1,"%d %d]",&mx,&my);
  315. X           dprintf(stderr,"Got %d,%d\n",mx,my);
  316. X
  317. X           menu = -1;
  318. X           if (my < y0) {            /* button 1 hit on menu */
  319. X              for(i=0;i<4;i++)
  320. X                  if (mx<marks[i]) {
  321. X                     menu = i+1;
  322. X                     break;
  323. X                     }
  324. X              }
  325. X
  326. X           else {
  327. X              lastx = -1;
  328. X              last = set_undo(last,map);
  329. X              while (*line != '$') {        /* button 1 hit on bitmap */
  330. X                 bitx = (mx-GAP)/x;
  331. X                 bity = (my-2*GAP-font_high)/y;
  332. X                 dprintf(stderr,"read (%d/%d,%d/%d) was (%d,%d) %s",
  333. X                         bitx,W(map),bity,H(map),lastx,lasty,line);
  334. X
  335. X                 if (lastx == -1)  {
  336. X                    mode = bit_on(map,bitx,bity) ? CLEAR : SET;
  337. X                    title[T_FUNC]=modes[mode].value;
  338. X                    Do_title(title);
  339. X                    }
  340. X   
  341. X                 if (bitx==lastx && bity == lasty) {
  342. X                    dprintf(stderr,"same bit %d,%d\n",bitx,bity);
  343. X                    }
  344. X                 else if (bitx < W(map) && bity < H(map)) {
  345. X                    do_bit(map,x,y,bitx,bity,mode);
  346. X                    }
  347. X                 else {
  348. X                    dprintf(stderr,"? bit %d,%d\n",bitx,bity);
  349. X                    }
  350. X
  351. X                 lastx=bitx; lasty=bity;
  352. X                 m_getinfo(G_MOUSE2);
  353. X                 m_flush();
  354. X                 m_gets(line);
  355. X                 sscanf(line,"%d %d",&mx,&my);
  356. X                 if (debug) sleep(1);
  357. X                 }
  358. X              }
  359. X
  360. X           /* set menu (if any) */
  361. X
  362. X           if (menu>0) {
  363. X              dprintf(stderr,"selecting menu %d ->",menu); fflush(stderr);
  364. X              if (menu==M_MODES && function==PUT)
  365. X                 menu=M_PUT;
  366. X              m_selectmenu(menu);
  367. X              dprintf(stderr," %d [%d]\n",menu,function);
  368. X              }
  369. X           break;
  370. X        case '(':            /* swept area  */
  371. X           {
  372. X           int rx1,ry1,rx2,ry2;        /* rect coords */
  373. X
  374. X           sscanf(line+1,"%d %d %d %d)",&rx1,&ry1,&rx2,&ry2);
  375. X
  376. X           if (rx1>rx2) SWAP(rx1,rx2);
  377. X           if (ry1>ry2) SWAP(ry1,ry2);
  378. X
  379. X           rx1 = Max(rx1,x0);
  380. X           ry1 = Max(ry1,y0);
  381. X
  382. X           rx1 = (rx1-GAP)/x;
  383. X           rx2 = (rx2-GAP)/x;
  384. X           ry1 = (ry1-2*GAP-font_high)/y;
  385. X           ry2 = (ry2-2*GAP-font_high)/y;
  386. X
  387. X           rx2 = Min(rx2,W(map));
  388. X           ry2 = Min(ry2,H(map));
  389. X
  390. X           w = rx2 - rx1;
  391. X           h = ry2 - ry1;
  392. X           new = bit_create(map,rx1,ry1,w,h);
  393. X           dprintf(stderr,"Extract %d,%d %dx%d code: %s\n",
  394. X                           rx1,ry1,w,h,new?"YES":"NO");
  395. X
  396. X           last = set_undo(last,map);
  397. X
  398. X           if (function) {
  399. X              INVERT(T_OP);
  400. X              dprintf(stderr,"Doing function %d\n",function);
  401. X              switch(function) {
  402. X                 case YANK:
  403. X                    if (yanked)
  404. X                       bit_destroy(yanked);
  405. X                    yanked = bit_alloc(W(new),H(new),BIT_NULL,1);
  406. X                    bit_blit(yanked,0,0,
  407. X                            W(new),H(new),BIT_SRC,new,0,0);
  408. X                    dprintf(stderr,"yanked: %s\n",yanked?"YES":"NO");
  409. X                    if (!yanked)
  410. X                       message(SETMSG,"Can't yank bitmap");
  411. X                    else
  412. X                       message(SETMSG,sprintf(line,"Yanked bitmap %d x %d",
  413. X                               W(new),H(new)));
  414. X                    break;
  415. X                 case PUT:
  416. X                    if (!yanked) {
  417. X                       message(SETMSG,"Nothing to PUT");
  418. X                       break;
  419. X                       }
  420. X
  421. X                    w = Min(W(yanked),W(new));
  422. X                    h = Min(H(yanked),H(new));
  423. X
  424. X                    if (w<1 || h < 1) {
  425. X                       message(SETMSG,"Put where??");
  426. X                       break;
  427. X                       }
  428. X
  429. X                    /* setup and zoom bitmap */
  430. X
  431. X                    temp = bit_alloc(w,h,BIT_NULL,1);
  432. X                    bit_blit(temp,0,0,w,h,BIT_SRC,new,0,0);
  433. X                    bit_blit(temp,0,0,w,h,func_zoom[put],yanked,0,0);
  434. X                    zoom(temp,x0+rx1*x,y0+ry1*y,x,y,SET);
  435. X                    bit_destroy(temp);
  436. X
  437. X                    bit_blit(new,0,0,w,h,func_put[put],yanked,0,0);
  438. X                    title[T_FUNC] = modes[mode].value;
  439. X                    Do_title(title);
  440. X                    dprintf(stderr,"put:%dx%d at %d,%d [%d]\n",
  441. X                            w,h,rx1,ry1,put);
  442. X                    break;
  443. X                 case SHRINK:
  444. X                    w = W(new);
  445. X                    h = H(new);
  446. X                    if (w<MIN || h<MIN) {
  447. X                       message(SETMSG,"Icon would be too small");
  448. X                       break;
  449. X                       }
  450. X                    temp = bit_alloc(w,h,BIT_NULL,1);
  451. X                    bit_blit(temp,0,0,w,h,BIT_SRC,new,0,0);
  452. X                    bit_destroy(new);
  453. X                    bit_destroy(map);
  454. X                    new = BIT_NULL;
  455. X                    map = temp;
  456. X                    get_scale(&x,&y,map);
  457. X                    m_clear();
  458. X                    zoom(map,x0,y0,x,y,SET);
  459. X                    if (grid)
  460. X                       draw_grid(map,x0,y0,x,y);
  461. X                    title[T_SIZE] = sprintf(dims,"%d x %d",
  462. X                            W(map),H(map));
  463. X                    Do_title(title);
  464. X                    break;
  465. X                 case GROW:
  466. X                    w = W(map)*W(map)/W(new);
  467. X                    h = H(map)*H(map)/H(new);
  468. X                    if (w>MAX || h>MAX) {
  469. X                       message(SETMSG,"Icon would be too big");
  470. X                       break;
  471. X                       }
  472. X                    temp = bit_alloc(w,h,BIT_NULL,1);
  473. X                    fprintf(stderr,"growing to %d , %d\n",w,h);
  474. X                    bit_blit(temp,0,0, w,h,BIT_CLR,0,0,0);
  475. X                    bit_blit(temp,rx1,ry1,W(map),H(map),BIT_SRC,map,0,0);
  476. X                    bit_destroy(new);
  477. X                    bit_destroy(map);
  478. X                    new = BIT_NULL;
  479. X                    map = temp;
  480. X                    get_scale(&x,&y,map);
  481. X                    m_clear();
  482. X                    zoom(map,x0,y0,x,y,SET);
  483. X                    if (grid)
  484. X                       draw_grid(map,x0,y0,x,y);
  485. X                    title[T_SIZE] = sprintf(dims,"%d x %d",
  486. X                            W(map),H(map));
  487. X                    Do_title(title);
  488. X                    break;
  489. X                 case SHIFT:
  490. X                    bit_blit(map,0,0,W(map),H(map)-1,BIT_SRC,map,0,1);
  491. X                    zoom(map,x0,y0,x,y,SET);
  492. X                    if (grid)
  493. X                       draw_grid(map,x0,y0,x,y);
  494. X                    break;
  495. X                 }
  496. X              function = 0;
  497. X              }
  498. X           else {
  499. X              if (new && mode==TOGGLE) {
  500. X                 bit_blit(new,0,0,W(new),H(new),
  501. X                          BIT_NOT(BIT_DST),0,0,0);
  502. X                 m_bitwrite(x0+rx1*x,y0+ry1*y,x*W(new),
  503. X                            y*H(new));
  504. X                 }
  505. X              else if (new) {
  506. X                 zoom(new,x0+rx1*x,y0+ry1*y,x,y,mode==SET?CLEAR:SET);
  507. X                 bit_blit(new,0,0,W(new),H(new),
  508. X                          mode==SET?BIT_SET:BIT_CLR,0,0,0);
  509. X                 }
  510. X              if (new)
  511. X                 bit_destroy(new);
  512. X              }
  513. X           }
  514. X           break;
  515. X        case '$':            /* button up */
  516. X           dprintf(stderr,"done\n");
  517. X           menu = -1;
  518. X           m_nomenu();
  519. X           break;
  520. X        case 's':            /* set bit mode */
  521. X           c = *(line+1);
  522. X           if (c>='0' && c<='2')
  523. X              code = c - '0';
  524. X           if (mode != code){
  525. X              mode = code;
  526. X              title[T_FUNC]=modes[mode].value;
  527. X              Do_title(title);
  528. X              }
  529. X           break;
  530. X        case '+':            /* specify bitmap size */
  531. X           pntr=get_str("Enter new size (xxx,yyy):\n",
  532. X                     mx,my,sizes,MENU_SIZE(sizes));
  533. X           sscanf(pntr,"%d,%d",&w,&h);
  534. X           if (w>MAX || h>MAX || w<MIN || h<MIN) {
  535. X              message(SETMSG,"Sorry, invalid size");
  536. X              break;
  537. X              }
  538. X           temp = bit_alloc(w,h,BIT_NULL,1);
  539. X           fprintf(stderr,"resizing to %d , %d\n",w,h);
  540. X           mx = w>W(map) ? (w - W(map))/2 : 0;
  541. X           my = h>H(map) ? (h - H(map))/2 : 0;
  542. X           bit_blit(temp,0,0,w,h,BIT_CLR,0,0,0);
  543. X           bit_blit(temp,mx,my,W(map),H(map),BIT_SRC,map,0,0);
  544. X           bit_destroy(map);
  545. X           map = temp;
  546. X           get_scale(&x,&y,map);
  547. X           m_clear();
  548. X           zoom(map,x0,y0,x,y,SET);
  549. X           if (grid)
  550. X              draw_grid(map,x0,y0,x,y);
  551. X           title[T_SIZE] = sprintf(dims,"%d x %d",W(map),H(map));
  552. X           Do_title(title);
  553. X           if (function)
  554. X              INVERT(T_OP);
  555. X           break;
  556. X        case 'f':            /* save file */
  557. X           if ((pntr=get_str("Enter file name:\n",mx,my,files,file_count))
  558. X                                  && *pntr) {
  559. X              if (write_icon(pntr,map) && strcmp(name,pntr)!=0) {
  560. X                 title[T_NAME] = strcpy(name,pntr);
  561. X                 Do_title(title);
  562. X                 if (function) INVERT(T_OP);
  563. X              
  564. X                 /* add new name to menu */
  565. X
  566. X                 for(i=0;i<file_count;i++)
  567. X                    if (strcmp(files[i].value,name)==0)
  568. X                       break;
  569. X                 if (i==file_count && file_count+1 < FILES) {
  570. X                    files[file_count].value = str_save(name,"");
  571. X                    files[file_count].action = str_save(name,"\r");
  572. X                    file_count++;
  573. X                    }
  574. X                 }
  575. X              }
  576. X           else {
  577. X              message(SETMSG,"No file saved");
  578. X              }
  579. X           break;
  580. X        case 'g':            /* get file */
  581. X           {
  582. X           pntr = get_str("Enter file name:\n",mx,my,files,file_count);
  583. X           if (pntr && *pntr && (new = read_icon(pntr,0))  != BIT_NULL) {
  584. X              bit_destroy(map);
  585. X              map=new;
  586. X              m_clear();
  587. X              code = get_scale(&x,&y,map);
  588. X              zoom(map,x0,y0,x,y,SET);
  589. X              title[T_SIZE] = sprintf(dims,"%d x %d",W(map),H(map));
  590. X              title[T_NAME] = strcpy(name,pntr);
  591. X              Do_title(title);
  592. X              if (grid)
  593. X                 draw_grid(map,x0,y0,x,y);
  594. X              }
  595. X           }
  596. X           break;
  597. X        case 'y':            /* yank file to buffer */
  598. X           pntr = get_str("Enter file name:\n",mx,my,files,file_count);
  599. X           if (pntr && *pntr && (new = read_icon(pntr,0))  != BIT_NULL) {
  600. X              if (yanked)
  601. X                 bit_destroy(yanked);
  602. X              yanked = new;
  603. X              new = BIT_NULL;
  604. X              message(SETMSG,sprintf(line,"Yanked %s (%d x %d)",
  605. X                      pntr,W(yanked),H(yanked)));
  606. X              if (function == YANK) {
  607. X                 INVERT(T_OP); 
  608. X                 function = 0;
  609. X                 }
  610. X              }
  611. X           else
  612. X              message(SETMSG,"Can'y yank file");
  613. X           break;
  614. X        case 'w':            /* reshape window to icon size  */
  615. X           code = Min(x,y);
  616. X           m_shapewindow(win_x,win_y,W(map)*code+GAP+2*border,
  617. X                        W(map)*code+2*font_high+GAP*3 + 2*border);
  618. X           m_sendme("S\r");
  619. X           break;
  620. X        case 'P':            /* set put mode  */
  621. X           code = *(line+1) - '0';
  622. X           if (code<0 || code > 9)
  623. X              code = 0;
  624. X           if (put != code) {
  625. X              put = code;
  626. X              title[T_FUNC]=functions[put].value;
  627. X              Do_title(title);
  628. X              INVERT(T_OP);
  629. X              }
  630. X           break;
  631. X        case 'F':            /* set option flags  */
  632. X           code = *(line+1) - '0';
  633. X
  634. X           if (code<0 || code > 9)
  635. X              break;
  636. X           if (code == PUT && !yanked)
  637. X              break;
  638. X
  639. X           if (code == function && function == PUT) {
  640. X              function = 0;
  641. X              title[T_FUNC] = modes[mode].value;
  642. X              }
  643. X           else if (code == function)
  644. X              function = 0;
  645. X           else {
  646. X              function = code;
  647. X              title[T_OP] = options[function-1].value;
  648. X              dprintf(stderr,"setting function =  %d\n",code);
  649. X              if (function == PUT)
  650. X                 title[T_FUNC]=functions[put].value;
  651. X              }
  652. X           Do_title(title);
  653. X           if (function)
  654. X              INVERT(T_OP);
  655. X           break;
  656. X        case 'u':            /* undo */
  657. X           if (!last)
  658. X              break;
  659. X
  660. X           /* get ready to undo the undo */
  661. X
  662. X           temp = map;
  663. X           map = last;
  664. X           last = temp;
  665. X
  666. X           /* make changes in situ */
  667. X
  668. X           if (W(last)==W(map) && H(last)==H(map)) {
  669. X              temp = bit_alloc(W(map),H(map),BIT_NULL,1);
  670. X              bit_blit(temp,0,0,W(map),H(map),BIT_SRC,map,0,0);
  671. X              bit_blit(temp,0,0,W(map),H(map),BIT_SRC^BIT_DST,last,0,0);
  672. X              zoom(temp,x0,y0,x,y,SET);
  673. X              bit_destroy(temp);
  674. X              }
  675. X
  676. X           /* redoit all */
  677. X
  678. X           else {
  679. X              get_scale(&x,&y,map);
  680. X              m_clear();
  681. X              zoom(map,x0,y0,x,y,SET);
  682. X              if (grid)
  683. X                 draw_grid(map,x0,y0,x,y);
  684. X              title[T_SIZE] = sprintf(dims,"%d x %d", W(map),H(map));
  685. X              Do_title(title);
  686. X              }
  687. X           break;
  688. X        case 'M':            /* move */
  689. X           get_size(&win_x,&win_y,0,0);
  690. X           break;
  691. X        case 'R':            /* redraw */
  692. X           m_clear();
  693. X           zoom(map,x0,y0,x,y,SET);
  694. X           Do_title(title);
  695. X           if (grid)
  696. X              draw_grid(map,x0,y0,x,y);
  697. X           if (function)
  698. X              INVERT(T_OP);
  699. X           break;
  700. X        case 'S':            /* reshape */
  701. X              {
  702. X              int lastx = x;
  703. X              int lasty = y;
  704. X
  705. X              get_font(&font_wide, &font_high);
  706. X              code = get_scale(&x,&y,map);
  707. X              if (code>0 || lastx != x || lasty != y) {
  708. X                 m_clear();
  709. X                 zoom(map,x0,y0,x,y,SET);
  710. X                 if (grid)
  711. X                    draw_grid(map,x0,y0,x,y);
  712. X                 }
  713. X              Do_title(title);
  714. X              if (function)
  715. X                 INVERT(T_OP);
  716. X              }
  717. X              break;
  718. X        case 'Q':            /* quit */
  719. X           done++;
  720. X           m_gets(line);        /* eat the "$" */
  721. X           break;
  722. X        case 'x':            /* toggle grid */
  723. X           draw_grid(map,x0,y0,x,y);
  724. X           grid = 1-grid;
  725. X           break;
  726. X        default:
  727. X           break;
  728. X        }
  729. X     m_flush();
  730. X     }
  731. X   clean(0);
  732. X   }
  733. X
  734. X/* grid a bitmap onto the window */
  735. X
  736. Xint
  737. Xdraw_grid(map,x,y,x_scale,y_scale)
  738. Xregister BITMAP *map;        /* bitmap to zoom */
  739. Xint x,y;            /* screen location to start */
  740. Xint x_scale, y_scale;        /* scale factors (>1) */
  741. X   {
  742. X   register int sx,sy,dx,dy;    /* current src, dst coords */
  743. X
  744. X   for(dy=y,sy=0;sy<H(map);sy++,dy+=y_scale)
  745. X            m_bitwrite(x,dy,W(map)*x_scale,1);
  746. X   for(dx=x,sx=0;sx<W(map);sx++,dx+=x_scale)
  747. X            m_bitwrite(dx,y,1,H(map)*y_scale);
  748. X   } 
  749. X
  750. X/* zoom a bitmap onto the window */
  751. X
  752. X#define X_ON(x)    (x != -1)
  753. X
  754. Xint
  755. Xzoom(map,x,y,x_scale,y_scale,how)
  756. Xregister BITMAP *map;        /* bitmap to zoom */
  757. Xint x,y;            /* screen location to start */
  758. Xint x_scale, y_scale;        /* scale factors (>1) */
  759. Xint how;            /* 1==on bits  0==off bits */
  760. X   {
  761. X   register int sx,sy,dx,dy;    /* current src, dst coords */
  762. X   int on, count=0, set_x;
  763. X
  764. X   for(dy=y,sy=0;sy<H(map);sy++,dy+=y_scale) {
  765. X      for(count=0,dx=x,sx=0;sx<W(map);sx++,dx+=x_scale) {
  766. X         on = how==SET ? (bit_on(map,sx,sy)) : !(bit_on(map,sx,sy));
  767. X         if (on && count)
  768. X            count ++;
  769. X         else if (on) {
  770. X            count++;
  771. X            set_x = dx;
  772. X            }
  773. X         else if (count) {
  774. X            m_bitwrite(set_x,dy,count * x_scale,y_scale);
  775. X            count = 0;
  776. X            }
  777. X         }
  778. X      if (count)
  779. X         m_bitwrite(set_x,dy,count * x_scale,y_scale);
  780. X      }
  781. X   } 
  782. X
  783. X
  784. Xint
  785. Xclean(n)
  786. Xint n;
  787. X   {
  788. X   m_moveprint(0,win_high,"done...");
  789. X   m_popall();
  790. X   m_ttyreset();
  791. X   exit(n);
  792. X   }
  793. X
  794. Xmessage(how,s)
  795. Xint how;
  796. Xchar *s;
  797. X   {
  798. X   alarm(0);
  799. X   if (how==SETMSG) {
  800. X      m_moveprint(0,win_high,s);
  801. X      m_flush();
  802. X      dprintf(stderr,"Setting message [%s]\n",s);
  803. X      alarm(SLEEP);
  804. X      }
  805. X   else {
  806. X      m_movecursor(0,win_high);
  807. X      dprintf(stderr,"clearing message\n");
  808. X      }
  809. X   m_cleareol();
  810. X   m_movecursor(win_wide,win_high);
  811. X   m_flush();
  812. X   }
  813. X
  814. Xint Do_title(args)
  815. Xchar **args;
  816. X   {
  817. X   register int i, count;
  818. X   int len[MAXMARK];        /* label sizes */
  819. X   int sum;            /* total label width */
  820. X   int x = 0;            /* starting label position */
  821. X   int y = font_high;        /* starting label position */
  822. X   register char **label=args;
  823. X
  824. X   SET_FUNC(B_SET);
  825. X   m_movecursor(0,y);
  826. X   m_cleareol();
  827. X
  828. X   for(sum=count=0;*label;count++,label++)
  829. X      sum += (len[count] = strlen(*label) * font_wide + GAP);
  830. X   for(i=0;i<count;i++) {
  831. X      marks[i] = MARK(i-1) + len[i] * win_wide / sum;
  832. X      if (i+1 == count)
  833. X         marks[i] = win_wide;        /* fix rounding error */
  834. X      dprintf(stderr,"%s (%d)at %d=>%d ",
  835. X              args[i],len[i],MARK(i-1),MARK(i));
  836. X      if (MARK(i) - MARK(i-1) > len[i])
  837. X         m_moveprint((MARK(i)+MARK(i-1)- len[i])/2,y,args[i]);
  838. X      m_bitwrite(marks[i],0,GAP,y);
  839. X      }
  840. X   dprintf(stderr,"(%d)\n",win_wide);
  841. X
  842. X   m_bitwrite(0,y,win_wide,GAP);
  843. X   m_movecursor(win_wide+font_wide,y);
  844. X   SET_FUNC(B_INVERT);
  845. X   
  846. X   return(count);
  847. X   }
  848. X
  849. X/* get a user string */
  850. X
  851. X
  852. Xchar *
  853. Xget_str(s,x,y,menu,count)
  854. Xchar *s;            /* text to display */
  855. Xint x,y;            /* center of window */
  856. Xstruct menu_entry *menu;    /* menu to down load */
  857. Xint count;            /* # of menu items */
  858. X   {
  859. X   static char input[128];
  860. X   int wide = Max(15,strlen(s)) * font_wide + 2*border;
  861. X   int high = 2*(font_high + border);
  862. X   int x0 = win_x + x - wide/2;
  863. X   int y0 = win_y + y + font_high;
  864. X   int win;
  865. X   char *pntr, *index();
  866. X
  867. X   if (x0<0)
  868. X      x0 = GAP;
  869. X   if (x0+wide > xmax)
  870. X      x0 = xmax-wide-GAP;
  871. X   if (y0+high > ymax)
  872. X      y0 = ymax-high-GAP;
  873. X
  874. X   dprintf(stderr,"Making %d,%d %dx%d\n",x0,y0,wide,high);
  875. X   message(SIGALRM);        /* turn of any pending message */
  876. X
  877. X   m_newwin(x0,y0,wide,high);
  878. X   m_flush();
  879. X   m_gets(input);
  880. X   if (*input == '$') {        /* button already let go */
  881. X      dprintf(stderr,"$ in makewin\n");
  882. X      m_gets(input);
  883. X      }
  884. X
  885. X   dprintf(stderr,"makewin returns %s",input);
  886. X   win = atoi(input);
  887. X   dprintf(stderr,"Created %d\n",win);
  888. X
  889. X   *input = '\0';
  890. X   if (win) {
  891. X      m_selectwin(win);
  892. X      m_setevent(DEACTIVATED,"\r");
  893. X      m_setevent(DESTROY,"\r");
  894. X      m_setevent(RESHAPE,"\r");
  895. X      m_setevent(BUTTON_1,"%n\r");
  896. X      m_setevent(ACCEPT,"%m\r");
  897. X      if (count > 0) {
  898. X         menu_load(1,count,menu);
  899. X         m_selectmenu(1);
  900. X         }
  901. X      m_printstr(s);
  902. X      dprintf(stderr,"prompt: %s ...",s);
  903. X      fflush(stderr);
  904. X      m_flush();
  905. X      m_ttyreset();
  906. X      m_gets(input);
  907. X
  908. X      pntr = input;
  909. X      if (pntr=index(input,' '))
  910. X         *pntr='\0';
  911. X      if (pntr=index(input,'\n'))
  912. X         *pntr='\0';
  913. X
  914. X      m_ttyset();
  915. X      dprintf(stderr,"Got: %s\n",input); fflush(stderr);
  916. X      m_selectwin(0);
  917. X      m_destroywin(win);
  918. X      m_flush();
  919. X      } 
  920. X   else
  921. X      message(SETMSG,"Sorry, Can't make prompt window");
  922. X   return(input);
  923. X   }
  924. X
  925. X/* read in icon */ 
  926. X
  927. XBITMAP *
  928. Xread_icon(name)
  929. Xchar *name;                /* name of icon file */
  930. X   {
  931. X   FILE *fp;                /* fp to read bitmap from */
  932. X   BITMAP *map, *bitmapread();
  933. X   char tmp[100];
  934. X
  935. X   if ((fp = fopen(name,"r")) == NULL ) {
  936. X      message(SETMSG,sprintf(tmp,"Can't find %s",name));
  937. X      return(BIT_NULL);
  938. X      }
  939. X
  940. X   if( !( map = bitmapread(fp) ) ) {
  941. X      fclose(fp);
  942. X      message(SETMSG,sprintf(tmp,"%s is not an icon or is damaged",name));
  943. X      return(BIT_NULL);
  944. X      }
  945. X
  946. X   fclose(fp);
  947. X   return(map);
  948. X   }
  949. X
  950. Xint
  951. Xget_scale(x,y,map)
  952. Xregister int *x, *y;
  953. XBITMAP *map;
  954. X   {
  955. X   char line[256];
  956. X   int w = W(map);
  957. X   int h = H(map);
  958. X   int count;
  959. X
  960. X   for(count=0;;count++) {
  961. X      get_size(&win_x,&win_y,&win_wide,&win_high);
  962. X      *x = (win_wide - x0)/w;
  963. X      *y = (win_high - y0 - font_high)/h;
  964. X      if (*x>=1 && *y>=1) 
  965. X         break;
  966. X      m_clear();
  967. X      m_clearmode(M_NOWRAP);
  968. X      m_printstr("Window is too small\n");
  969. X      m_gets(line); 
  970. X      }
  971. X   if (count)
  972. X      m_setmode(M_NOWRAP);
  973. X   return(count);
  974. X   }
  975. X
  976. X
  977. Xint
  978. Xwrite_icon(name,map)
  979. Xchar *name;
  980. XBITMAP *map;
  981. X   {
  982. X   FILE *fp = fopen(name,"w");
  983. X   char tmp[100];
  984. X
  985. X   if (fp == NULL  ||  !bitmapwrite(fp,map)) {
  986. X      dprintf(stderr,"Can't write file %s\n",name);
  987. X      message(SETMSG,sprintf(tmp,"Can't write file %s",name));
  988. X      return(0);
  989. X      }
  990. X   fclose(fp);
  991. X   return(1);
  992. X   }
  993. X
  994. X/* do mode to bit, fix up display */
  995. X
  996. Xint
  997. Xdo_bit(map,x,y,bitx,bity,mode)
  998. XBITMAP *map;
  999. Xint x,y;        /* scale factors */
  1000. Xint bitx,bity;        /* bit to do */
  1001. Xint mode;        /* SET, CLEAR, or TOGGLE */
  1002. X   {
  1003. X   int state = bit_on(map,bitx,bity) ? ON : OFF;
  1004. X   switch(mode | state) {
  1005. X      case TOGGLE | OFF:
  1006. X      case TOGGLE | ON:
  1007. X      case SET | OFF:
  1008. X      case CLEAR | ON:
  1009. X         bit_point(map,bitx,bity,BIT_NOT(BIT_DST));
  1010. X         m_bitwrite(x0+bitx*x,y0+bity*y,x,y);
  1011. X         dprintf(stderr,"toggle (%d)\n",mode|state);
  1012. X         break;
  1013. X      }
  1014. X   }
  1015. X
  1016. X/* save map for undo */
  1017. X
  1018. XBITMAP *
  1019. Xset_undo(last,map)
  1020. XBITMAP *last, *map;
  1021. X   {
  1022. X   if (!last)
  1023. X      last = bit_alloc(W(map),H(map),BIT_NULL,1);
  1024. X   else if (W(last)!=W(map) || H(last)!=H(map)) {
  1025. X      bit_destroy(last);
  1026. X      last = bit_alloc(W(map),H(map),BIT_NULL,1);
  1027. X      }
  1028. X   bit_blit(last,0,0,W(last),H(last),BIT_SRC,map,0,0);
  1029. X   return(last);
  1030. X   }
  1031. X
  1032. X/* alloc and save space for the concatenation of s1 and s2 */
  1033. X
  1034. Xchar *str_save(s1,s2)
  1035. Xchar *s1, *s2;
  1036. X   {
  1037. X   char *malloc();
  1038. X   char *result;
  1039. X
  1040. X   if ((result = malloc(strlen(s1) + strlen(s2) + 1)) == NULL) {
  1041. X      fprintf(stderr,"Malloc failed\n");
  1042. X      clean(1);  
  1043. X      }
  1044. X
  1045. X   strcpy(result,s1);
  1046. X   strcat(result,s2);
  1047. X   return(result);
  1048. X   }
  1049. END_OF_FILE
  1050. # end of 'demo/icon/zoom.c'
  1051. fi
  1052. echo shar: End of archive 46 \(of 61\).
  1053. cp /dev/null ark46isdone
  1054. MISSING=""
  1055. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  1056.     21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 \
  1057.     38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 \
  1058.     55 56 57 58 59 60 61 ; do
  1059.     if test ! -f ark${I}isdone ; then
  1060.     MISSING="${MISSING} ${I}"
  1061.     fi
  1062. done
  1063. if test "${MISSING}" = "" ; then
  1064.     echo You have unpacked all 61 archives.
  1065.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1066. else
  1067.     echo You still need to unpack the following archives:
  1068.     echo "        " ${MISSING}
  1069. fi
  1070. ##  End of shell archive.
  1071. exit 0
  1072.