home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume6 / xscan / part01 next >
Internet Message Format  |  1990-04-11  |  58KB
  1. Path: uunet!cs.utexas.edu!sun-barr!newstop!sun!Aus
  2. From: richb@Aus (Rich Burridge)
  3. Newsgroups: comp.sources.x
  4. Subject: v06i071: Scantool -- Read from a scanner, Part01/03
  5. Message-ID: <134361@sun.Eng.Sun.COM>
  6. Date: 12 Apr 90 09:12:46 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 1707
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: richb@Aus (Rich Burridge)
  12. Posting-number: Volume 6, Issue 71
  13. Archive-name: xscan/part01
  14.  
  15.  
  16. This is version 1.4 of the scantool program. It can interface to a Microtek
  17. MS300A scanner, scan the document, and turn the image into a Sun rasterfile,
  18. which can be read by dtp programs such as Frame Maker.
  19.  
  20. There are grtaphical interfaces for XView and SunView, and it would be fairly
  21. easy to "knock up" an interface to other X11 toolkits that supported frames,
  22. drawing canvases and popup menus.
  23.  
  24. The software is now divided into two programs; scantool a frontend window
  25. based program for setting the scanning options, and scan, the program that
  26. will actually perform the scan. It should also be possible to run this
  27. scan program on it's own, but there are several command line options to
  28. setup, so it's probably easier through scantool.
  29.  
  30. **IMPORTANT NOTE**
  31.  
  32. I no longer have access to a Microtek MS300A scanner. If you find problems
  33. in this area, then you are on your own. I will be very happy to incorporate
  34. any fixes you make, so other people can enjoy them as well.
  35.  
  36. Suggestions for furthur improvement would be most welcome, plus bugs,
  37. comments and flames.
  38.  
  39. Rich Burridge,          DOMAIN: richb@Aus.Sun.COM
  40. PHONE: +61 2 413 2666   ACSNET: richb@sunaus.sun.oz
  41.                         UUCP:   {uunet,mcvax,ukc}!munnari!sunaus.oz!richb
  42.  
  43.    File Name        Archive #    Description
  44. ----------------------------------------------------------
  45.  scantool                   1    
  46.  scantool/CHANGES           3    
  47.  scantool/Imakefile         3    
  48.  scantool/Makefile          2    
  49.  scantool/README            3    
  50.  scantool/black.codes       3    
  51.  scantool/button.invert.icon  3    
  52.  scantool/button.normal.icon  3    
  53.  scantool/exclaim.icon      3    
  54.  scantool/frame.cursor      3    
  55.  scantool/graphics.c        2    
  56.  scantool/help.cursor       3    
  57.  scantool/images.h          3    
  58.  scantool/main.cursor       3    
  59.  scantool/misc.c            2    
  60.  scantool/patchlevel.h      3    
  61.  scantool/scan.1            3    
  62.  scantool/scan.c            1    
  63.  scantool/scan.h            3    
  64.  scantool/scan_compress.c   2    
  65.  scantool/scan_extern.h     2    
  66.  scantool/scantool.1        2    
  67.  scantool/scantool.c        2    
  68.  scantool/scantool.h        3    
  69.  scantool/scantool.help     3    
  70.  scantool/scantool.icon     3    
  71.  scantool/scantool_extern.h  3    
  72.  scantool/sunview.c         1    
  73.  scantool/switch.invert.cursor  3    
  74.  scantool/switch.normal.cursor  1    
  75.  scantool/white.codes       3    
  76.  scantool/xview.c           1    
  77. ------CUT HERE------Part1of3------CUT HERE------
  78.  
  79. #! /bin/sh
  80. # This is a shell archive.  Remove anything before this line, then feed it
  81. # into a shell via "sh file" or similar.  To overwrite existing files,
  82. # type "sh file -c".
  83. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  84. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  85. # If this archive is complete, you will see the following message at the end:
  86. #        "End of archive 1 (of 3)."
  87. # Contents:  scantool scantool/scan.c scantool/sunview.c
  88. #   scantool/switch.normal.cursor scantool/xview.c
  89. # Wrapped by argv@turnpike on Thu Apr 12 02:08:22 1990
  90. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  91. if test ! -d 'scantool' ; then
  92.     echo shar: Creating directory \"'scantool'\"
  93.     mkdir 'scantool'
  94. fi
  95. if test -f 'scantool/scan.c' -a "${1}" != "-c" ; then 
  96.   echo shar: Will not clobber existing file \"'scantool/scan.c'\"
  97. else
  98. echo shar: Extracting \"'scantool/scan.c'\" \(19805 characters\)
  99. sed "s/^X//" >'scantool/scan.c' <<'END_OF_FILE'
  100. X
  101. X/*  @(#)scan.c 1.4 90/04/04
  102. X *
  103. X *  Program which will read a scanned image from a Microtek
  104. X *  MS-300A scanner and convert it to a Sun rasterfile.
  105. X *
  106. X *  Copyright (c) Rich Burridge.
  107. X *                Sun Microsystems, Australia - All rights reserved.
  108. X *
  109. X *  Permission is given to distribute these sources, as long as the
  110. X *  copyright messages are not removed, and no monies are exchanged.
  111. X *
  112. X *  No responsibility is taken for any errors or inaccuracies inherent
  113. X *  either to the comments or the code of this program, but if
  114. X *  reported to me, then an attempt will be made to fix them.
  115. X */
  116. X
  117. X#include <stdio.h>
  118. X#include <strings.h>
  119. X#include <signal.h>
  120. X#include <sgtty.h>
  121. X#include <rasterfile.h>
  122. X#include <sys/time.h>
  123. X#include <sys/types.h>
  124. X#include "patchlevel.h"
  125. X#include "scan.h"
  126. X
  127. Xchar cksum ;               /* Packets checksum. */
  128. Xchar cntbytes ;            /* Number of count bytes received. */
  129. Xchar finalimage[MAXLINE] ; /* Name of uncompressed image file. */
  130. Xchar from_rs[BUFSIZE] ;    /* Data received from the RS232. */
  131. Xchar line[MAXLINE] ;
  132. Xchar picname[MAXLINE] ;    /* Picture name for rasterfile output. */
  133. Xchar progname[MAXLINE] ;   /* Name of this program. */
  134. Xchar rscksum ;             /* RS232 read packet checksum. */
  135. Xchar rsdata[BUFSIZE] ;     /* Latest packet to/from the scanner. */
  136. Xchar rsrhold = XON ;       /* RS232 host hand shaking state. */
  137. Xchar rsrstate = RSSOR ;    /* State of RS232 read automation. */
  138. Xchar rsrtype ;             /* Record type received. */
  139. Xchar rswstate ;            /* RS232 write acknowledgement state. */
  140. Xchar scantype[MAXLINE] ;   /* Scanner details. */
  141. Xchar temphead[MAXLINE] ;   /* Temporary filename for header file. */
  142. Xchar tempimage[MAXLINE] ;  /* Temporary filename for saved scanned data. */
  143. X
  144. Xint brightness ;           /* Brightness value. */
  145. Xint cancel ;               /* Indicates if should cancel current scan. */
  146. Xint complete ;             /* Indicates if scanning is completed. */
  147. Xint contrast ;             /* Contrast value. */
  148. Xint error ;                /* Has an error report has been received? */
  149. Xint fd = -1 ;              /* File descriptor for RS232 line. */
  150. Xint finished ;             /* Indicates if we have finished uncompressing. */
  151. Xint fwidth ;               /* Final width of rasterfile. */
  152. Xint height ;               /* Height in scan lines of raster file image. */
  153. Xint pic_compressed = 0 ;   /* Whether any picture data was compressed. */
  154. Xint pkt_started = 0 ;      /* Is a data packet coming from the scanner? */
  155. Xint pktdone ;              /* Indicates if a complete packet received. */
  156. Xint rc ;                   /* Current character from scanned file. */
  157. Xint rcount ;               /* Count of bit position within read character. */
  158. Xint rscnt ;                /* Number of data bytes to read. */
  159. Xint rsptr ;                /* Character buffer pointer. */
  160. Xint wc ;                   /* Current character to write to final image file. */
  161. Xint wcount ;               /* Count of bit position within write character. */
  162. Xint width ;                /* Width in pixels of rasterfile image. */
  163. Xint grain ;                /* Grain value. */
  164. Xint resolution ;           /* Resolution value. */
  165. Xint retval ;               /* This programs exit status. */
  166. Xint rf ;                   /* File descriptor for raster image. */
  167. X
  168. Xint switches[4] =
  169. X      {
  170. X        0,                 /* Mode (Line Art). */
  171. X        1,                 /* Data Transfer (Compressed). */
  172. X        0,                 /* Serial Port (A). */
  173. X        1                  /* Baud Rate (19200). */
  174. X      } ;
  175. X
  176. Xint framevals[4] =            /* Initial frame in 1/8th inch intervals. */
  177. X      {
  178. X        16,                /* X1. */
  179. X        16,                /* Y1. */
  180. X        48,                /* X2. */
  181. X        48,                /* Y2. */
  182. X     } ;
  183. X
  184. XFILE *rd ;                 /* File descriptor for input files. */
  185. XFILE *wd ;                 /* File descriptor for final image. */
  186. X
  187. X#ifdef NO_4.3SELECT
  188. Xint readmask ;                /* File descriptors with outstanding reads. */
  189. X#else
  190. Xfd_set readmask ;             /* Readmask used in select call. */
  191. X#endif NO_4.3SELECT
  192. X
  193. Xstruct timeval timeout = { MAXTIME, 0 } ;
  194. X
  195. Xstruct code *whites[16] ;   /* White initial starting pointers. */
  196. Xstruct code *blacks[4] ;    /* Black initial starting pointers. */
  197. X
  198. X
  199. X/*  The scan program can exit is a variety of ways. These are:
  200. X *
  201. X *  0          - successful   - image saved in picname.
  202. X *  1          - unsuccessful - cannot open ttyline.
  203. X *  2          - unsuccessful - cannot open temporary image file.
  204. X *  3          - unsuccessful - cannot open raster header file.
  205. X *  4          - unsuccessful - scanner not responding. Aborting this scan.
  206. X *  5          - unsuccessful - invalid command line argument.
  207. X *  100 + 0xnn - unsuccessful - scanning error 0xnn received. Scan aborted.
  208. X *  200 + n    - unsuccessful - scan program terminated with signal n.
  209. X *
  210. X *  It is upto the calling program or shell script to display the
  211. X *  appropriate message back to the user.
  212. X */
  213. X
  214. Xmain(argc, argv)
  215. Xint argc ;
  216. Xchar *argv[] ;
  217. X{
  218. X  retval = 0 ;
  219. X  set_signals() ;              /* Set up a signal handler. */
  220. X  STRCPY(progname, argv[0]) ;  /* Save program name. */
  221. X  get_options(argc, argv) ;    /* Extract scanning parameters. */
  222. X  do_scan() ;                  /* Perform a scan using given parameters. */
  223. X  exit(retval) ;
  224. X}
  225. X
  226. X
  227. XSIGRET
  228. Xdo_exit(sig)   /* Signal received; exit gracefully. */
  229. Xint sig ;
  230. X{
  231. X  char outval ;
  232. X
  233. X  if (fd != -1)     /* Terminate the scan properly, if started. */
  234. X    {
  235. X      outval = ETX ;
  236. X      WRITE(fd, &outval, 1) ;
  237. X      CLOSE(fd) ;
  238. X    }
  239. X  exit(200 + sig) ;
  240. X}
  241. X
  242. X
  243. Xdo_handshake(value)            /* Send RS232 handshake XON/XOFF. */
  244. Xchar value ;
  245. X{
  246. X  WRITE(fd, &value, 1) ;
  247. X  rsrhold = value ;
  248. X}
  249. X
  250. X
  251. Xdo_scan()                      /* Perform a scan using given parameters. */
  252. X{
  253. X  char c ;                     /* Next character for RS232 output. */
  254. X
  255. X  pic_compressed = 0 ;
  256. X  height = 0 ;
  257. X  error = 0 ;                           /* Set to 1 on error. */
  258. X  if (open_temp_file() < 0) return ;    /* Open file for raster image. */
  259. X  if (init_rs_port(SERIAL_PORT, BAUD_RATE) < 0) return ;
  260. X 
  261. X/* Set scanning parameters. */
  262. X  if (make_packet('!', 1, 0) < 0) return ;    /* Get scanner model number. */
  263. X  if (make_packet('X', 1, 0) < 0) return ; ;  /* Reset scanning parameters. */
  264. X  if (make_packet('C', 2, DATA_TRANSFER) < 0) return ;
  265. X  if (MODE)
  266. X    {
  267. X      if (make_packet('H', 2, 0) < 0) return ;
  268. X    }
  269. X  else if (make_packet('T', 2, 0) < 0) return ;
  270. X  if (make_packet('G', 2, grain) < 0) return ;         /* Set up grain. */
  271. X  if (make_packet('B', 2, brightness) < 0) return ;    /* Set up brightness. */
  272. X  if (make_packet('K', 2, contrast) < 0) return ;      /* Set up contrast. */
  273. X  if (make_packet('R', 2, resolution+16) < 0) return ; /* Set up resolution. */
  274. X  if (make_frame_packet() < 0) return ;
  275. X  if (make_packet('S', 1, 0) < 0) return ;     /* Send a start scan packet. */ 
  276. X  complete = 0 ;
  277. X  cancel = 0 ;
  278. X  for (;;)
  279. X    {
  280. X 
  281. X#ifdef NO_4.3SELECT
  282. X      readmask = 1 << fd ;
  283. X      SELECT(32, &readmask, (int *) 0,(int *) 0, &timeout) ;
  284. X      if (readmask & (1 << fd))
  285. X#else
  286. X      FD_ZERO(&readmask) ;
  287. X      FD_SET(fd, &readmask) ;
  288. X      SELECT(FD_SETSIZE, &readmask, (fd_set *) 0, (fd_set *) 0, &timeout) ;
  289. X      if (FD_ISSET(fd, &readmask))
  290. X#endif NO_4.3SELECT
  291. X
  292. X        read_rs232() ;
  293. X      else
  294. X        { 
  295. X          if (rsrhold == XOFF) do_handshake(XON) ;
  296. X          if (pkt_started)
  297. X            {
  298. X              c = NAK ;
  299. X              WRITE(fd, &c, 1) ;
  300. X              rsrstate = RSSOR ;
  301. X              pkt_started = 0 ;
  302. X            }
  303. X        }    
  304. X      if (complete || error || cancel) break ;
  305. X    }
  306. X  CLOSE(rf) ;                     /* Close temporary image file. */
  307. X  if (!error)
  308. X    {
  309. X      save_picture() ;            /* Create Sun rasterfile picture. */
  310. X      retval = 0 ;                /* Successful exit - image saved. */
  311. X    }
  312. X  else UNLINK(tempimage) ;
  313. X  CLOSE(fd) ;
  314. X}
  315. X
  316. X
  317. Xget_options(argc, argv)        /* Extract command line options. */
  318. Xint argc ;
  319. Xchar *argv[] ;
  320. X{
  321. X  char next[MAXLINE] ;    /* The next command line parameter. */
  322. X
  323. X  INC ;
  324. X  while (argc > 0)
  325. X    {
  326. X      if (argv[0][0] == '-')
  327. X        switch (argv[0][1])
  328. X          {
  329. X            case 'b' : INC ;                         /* Brightness. */
  330. X                       getparam(next, argv, "-b needs brightness value") ;
  331. X                       brightness = atoi(next) ;
  332. X                       break ;
  333. X            case 'c' : INC ;                         /* Contrast. */
  334. X                       getparam(next, argv, "-c needs contrast value") ;
  335. X                       contrast = atoi(next) ;
  336. X                       break ;
  337. X            case 'd' : INC ;                         /* Data transfer. */
  338. X                       getparam(next, argv, "-d needs data transfer value") ;
  339. X                       switches[DATA_TRANSFER] = atoi(next) ;
  340. X                       break ;
  341. X            case 'f' : INC ;                         /* Frame. */
  342. X                       getparam(next, argv, "-f needs X1 coordinate") ;
  343. X                       framevals[X1] = atoi(next) ;
  344. X                       INC ;
  345. X                       getparam(next, argv, "-f needs Y1 coordinate") ;
  346. X                       framevals[Y1] = atoi(next) ;
  347. X                       INC ;
  348. X                       getparam(next, argv, "-f needs X2 coordinate") ;
  349. X                       framevals[X2] = atoi(next) ;
  350. X                       INC ;
  351. X                       getparam(next, argv, "-f needs Y2 coordinate") ;
  352. X                       framevals[Y2] = atoi(next) ;
  353. X                       break ;
  354. X            case 'g' : INC ;                         /* Grain. */
  355. X                       getparam(next, argv, "-g needs grain value") ;
  356. X                       grain = atoi(next) ;
  357. X                       break ;
  358. X            case 'm' : INC ;                         /* Mode. */
  359. X                       getparam(next, argv, "-m needs mode value") ;
  360. X                       switches[MODE] = atoi(next) ;
  361. X                       break ;
  362. X            case 'p' : INC ;                         /* Picture name. */
  363. X                       getparam(picname, argv, "-p needs picture name") ;
  364. X                       break ;
  365. X            case 'r' : INC ;                         /* Resolution. */
  366. X                       getparam(next, argv, "-r needs resolution value") ;
  367. X                       break ;
  368. X            case 's' : INC ;              /* Speed of RS232 connection. */
  369. X                       getparam(next, argv, "-s needs speed value") ;
  370. X                       switches[BAUD_RATE] = atoi(next) ;
  371. X                       break ;
  372. X            case 't' : INC ;                         /* Tty port. */
  373. X                       getparam(next, argv, "-t needs tty port") ;
  374. X                       switches[SERIAL_PORT] = atoi(next) ;
  375. X                       break ;
  376. X            case 'v' : FPRINTF(stderr, "%s version 1.4.%1d\n",
  377. X                                       progname, PATCHLEVEL) ;
  378. X                       break ;
  379. X            case '?' : usage() ;
  380. X          }
  381. X      INC ;
  382. X    }
  383. X}
  384. X
  385. X
  386. Xgetparam(s, argv, errmes)
  387. Xchar *s, *argv[], *errmes ;
  388. X{
  389. X  if (*argv != NULL && argv[0][0] != '-') STRCPY(s, *argv) ;
  390. X  else
  391. X    { 
  392. X      FPRINTF(stderr,"%s: %s as next argument.\n", progname, errmes) ;
  393. X      exit(5) ;
  394. X    }
  395. X}
  396. X
  397. X
  398. Xinit_rs_port(port, speed)              /* Initialise RS232 port. */
  399. Xint port, speed ;
  400. X{
  401. X  char ttyline[MAXLINE] ;
  402. X  struct sgttyb sgttyb ;
  403. X 
  404. X  if (port) STRCPY(ttyline, "/dev/ttyb") ;
  405. X  else      STRCPY(ttyline, "/dev/ttya") ;
  406. X  if ((fd = open(ttyline,2)) < 0)
  407. X    {
  408. X      retval = 1 ;      /* Cannot open ttyline. */
  409. X      return(-1) ;
  410. X    }
  411. X  GTTY(fd, &sgttyb) ;
  412. X  sgttyb.sg_flags |= RAW ;
  413. X  sgttyb.sg_flags &= ~(ECHO | CRMOD) ;
  414. X  if (speed) sgttyb.sg_ispeed = sgttyb.sg_ospeed = EXTA ;
  415. X  else       sgttyb.sg_ispeed = sgttyb.sg_ospeed = B9600 ;
  416. X  STTY(fd, &sgttyb) ;             /* Implement tty line setup changes. */
  417. X  return(0) ;
  418. X}
  419. X
  420. X
  421. Xmake_frame_packet()        /* Construct and send scanning frame packet. */
  422. X{
  423. X  char cksum ;             /* For creating the packet checksum. */
  424. X  int i ;
  425. X
  426. X  rsdata[0] = '\\' ;       /* Construct packet. */
  427. X  rsdata[1] = 0x80 ;
  428. X  rsdata[2] = 0x00 ;
  429. X  rsdata[3] = 5 ;
  430. X  rsdata[4] = 'F' ;
  431. X  rsdata[5] = framevals[X1] ;
  432. X  rsdata[6] = framevals[Y1] ;
  433. X  rsdata[7] = framevals[X2] ;
  434. X  rsdata[8] = framevals[Y2] ;
  435. X  cksum = 0 ;
  436. X  for (i = 1; i < 9; i++) cksum += rsdata[i] ;
  437. X  rsdata[9] = (~cksum) + 1 ;
  438. X  return(send_packet('F', 10)) ;
  439. X}
  440. X
  441. X
  442. Xmake_header(width, height)       /* Make Sun rasterfile header. */
  443. Xint width, height ;
  444. X{
  445. X  struct rasterfile header ;
  446. X  FILE *hd ;                    /* File descriptor for header file. */
  447. X
  448. X  SPRINTF(temphead, "/usr/tmp/%s.header", mktemp("XXXXXX")) ;
  449. X  if ((hd = fopen(temphead,"w")) == NULL)
  450. X    {
  451. X      retval = 3 ;              /* Can't open raster header file. */
  452. X      return(-1) ;
  453. X    }
  454. X  header.ras_magic = 0x59a66a95 ;        /* Generate rasterfile header. */
  455. X  header.ras_width = width ;
  456. X  header.ras_height = height ;
  457. X  header.ras_depth = 1 ;
  458. X  header.ras_length = width * height ;
  459. X  header.ras_type = RT_STANDARD ;
  460. X  header.ras_maptype = RMT_RAW ;
  461. X  header.ras_maplength = 0 ;
  462. X  FWRITE((char *) &header, sizeof(struct rasterfile), 1, hd) ;
  463. X  FCLOSE(hd) ;
  464. X  return(0) ;
  465. X}
  466. X
  467. X
  468. Xmake_packet(ptype, count, value)   /* Sent a packet to the scanner. */
  469. Xchar ptype, count, value ;
  470. X{
  471. X  char cksum ;                     /* For creating the packet checksum. */
  472. X  int i ;
  473. X  int len ;                        /* Length of this scanner packet. */
  474. X
  475. X  len = count + 5 ;
  476. X  rsdata[0] = '\\' ;               /* Construct packet. */
  477. X  rsdata[1] = 0x80 ;
  478. X  rsdata[2] = 0x00 ;
  479. X  rsdata[3] = count ;
  480. X  rsdata[4] = ptype ;
  481. X  if (count == 2) rsdata[5] = value ;
  482. X  cksum = 0 ;
  483. X  for (i = 1; i < len-1; i++) cksum += rsdata[i] ;
  484. X  rsdata[len-1] = (~cksum) + 1 ;
  485. X  return(send_packet(ptype, len)) ;
  486. X}
  487. X
  488. X
  489. Xopen_temp_file()          /* Open a temporary file for the scanned image. */
  490. X{
  491. X  SPRINTF(tempimage, "/usr/tmp/%s.image", mktemp("XXXXXX")) ;
  492. X  if ((rf = open(tempimage, 2)) < 0)
  493. X    if ((rf = creat(tempimage, 0777)) < 0)
  494. X      {
  495. X        retval = 2 ;   /* Can't open temporary image file. */
  496. X        return(-1) ;
  497. X      }
  498. X  return(0) ;
  499. X}
  500. X
  501. X
  502. Xprocess_packet(ptype)     /* Process RS232 packet received. */
  503. Xchar ptype ;
  504. X{
  505. X  int errorval ;          /* To extract error value. */
  506. X  char outval ;           /* ACK or NAK value to be sent. */
  507. X
  508. X  if (rscksum == cksum)
  509. X    {
  510. X      outval = ACK ;
  511. X      switch (ptype)
  512. X        {
  513. X          case 'D' : if ((rsrtype >> 5) & 1) pic_compressed++ ;
  514. X                     height++ ;
  515. X                     if (!((rsrtype >> 5) & 1)) rsptr = ((rsptr >> 2) << 2) ;
  516. X                     WRITE(rf, from_rs, rsptr) ;
  517. X                     width = rsptr * 8 ;
  518. X                     break ;
  519. X          case 'E' : outval = ETX ;    /* Complete scanning and eject paper. */
  520. X                     WRITE(fd, &outval, 1) ;
  521. X                     complete = 1 ;
  522. X                     break ;
  523. X          case '!' : STRNCPY(scantype, from_rs, rsptr) ;
  524. X                     break ;
  525. X          case '?' : errorval = (from_rs[1] & 0xFF) ;
  526. X                     retval = 100 + errorval ;  /* Scanning error received. */
  527. X                     outval = ETX ;
  528. X                     WRITE(fd, &outval, 1) ;
  529. X                     error = 1 ;
  530. X        }
  531. X    }    
  532. X  else outval = NAK ;
  533. X  WRITE(fd, &outval, 1) ;        /* Send ACK or NAK. */
  534. X  pktdone = 1 ;
  535. X}
  536. X
  537. X
  538. Xread_rs232()      /* Read upto end of next packet. */
  539. X{
  540. X  char c ;        /* Next character read from RS232. */
  541. X  int count ;     /* Number of RS232 characters to read. */
  542. X  int i ;
  543. X
  544. X  IOCTL(fd,(int) FIONREAD,(char *) &count) ;   /* Any data to read. */
  545. X  if (count > MAXREAD) do_handshake(XOFF) ;
  546. X  else if (count < 20 && rsrhold == XOFF) do_handshake(XON) ;
  547. X  if (!count) return ;                         /* NO: exit routine. */
  548. X  for (i = 0; i < count; i++)
  549. X    {
  550. X      READ(fd, &c, 1) ;                        /* Read next character. */
  551. X      if (rsrstate == RSSOR && (c == ACK || c == NAK)) rswstate = c ;
  552. X      else
  553. X        switch (rsrstate)
  554. X          {
  555. X            case RSSOR   : rscksum = 0 ;
  556. X                           if (c == SOR) rsrstate = RSRTYPE ;
  557. X                           break ;
  558. X            case RSRTYPE : rsrtype = c ;
  559. X                           rscksum += c ;
  560. X                           cntbytes = 0 ;
  561. X                           rscnt = 0 ;
  562. X                           rsrstate = RSCOUNT ;
  563. X                           break ;
  564. X            case RSCOUNT : rscksum += c ;
  565. X                           rscnt = rscnt*256 + c ;
  566. X                           if (++cntbytes == 2)
  567. X                             {
  568. X                               rsrstate = RSDATA ;
  569. X                               rsptr = 0 ;
  570. X                             }
  571. X                           pkt_started = 1 ;
  572. X                           break ;
  573. X            case RSDATA  : from_rs[rsptr++] = c ;  /* Save data character. */
  574. X                           rscksum += c ;
  575. X                           if (!--rscnt) rsrstate = RSCKSUM ;
  576. X                           break ;
  577. X            case RSCKSUM : rscksum = (~rscksum) + 1 ;
  578. X                           cksum = c ;
  579. X                           if (rsrtype >> 7) process_packet(from_rs[0]) ;
  580. X                           else process_packet('D') ;
  581. X                           pkt_started = 0 ;
  582. X                           rsrstate = RSSOR ;
  583. X                           return ;
  584. X          }
  585. X    }
  586. X}
  587. X
  588. X
  589. Xsave_picture()    /* Combine header file and image to make a Sun rasterfile. */
  590. X{
  591. X  char line[MAXLINE] ;          /* For constructing the system command. */
  592. X
  593. X  if (pic_compressed)
  594. X    {
  595. X      initialise_white("white.codes") ;
  596. X      initialise_black("black.codes") ;
  597. X      uncompress(tempimage) ;
  598. X    }
  599. X  else
  600. X    { 
  601. X      if (!make_header(width, height))   /* Write out Sun rasterfile header. */
  602. X        {
  603. X          SPRINTF(line, "cat %s %s > %s", temphead, tempimage, picname) ;
  604. X          SYSTEM(line) ;                 /* Create Sun rasterfile. */
  605. X          UNLINK(temphead) ;             /* Remove header file. */
  606. X        }
  607. X      UNLINK(tempimage) ;                /* Remove image file. */
  608. X    }
  609. X}
  610. X
  611. X
  612. Xsend_packet(ptype, len)
  613. Xchar ptype,len ;
  614. X{
  615. X  int done ;        /* Packet read or ACK/NAK found. */
  616. X  int i ;
  617. X
  618. X  for (i = 0; i < MAXRETRIES; i++)
  619. X    {
  620. X      WRITE(fd, rsdata, len) ;
  621. X      rswstate = NOANSWER ;
  622. X      pktdone = 0 ;
  623. X      done = 0 ;
  624. X      do
  625. X        {
  626. X#ifdef NO_4.3SELECT
  627. X          readmask = 1 << fd ;
  628. X          SELECT(32, &readmask, (int *) 0, (int *) 0, &timeout) ;
  629. X          if (readmask & (1 << fd))
  630. X#else
  631. X          FD_ZERO(&readmask) ;
  632. X          FD_SET(fd, &readmask) ;
  633. X          SELECT(FD_SETSIZE, &readmask, (fd_set *) 0, (fd_set *) 0, &timeout) ;
  634. X          if (FD_ISSET(fd, &readmask))
  635. X#endif NO_4.3SELECT
  636. X            {
  637. X              read_rs232() ;
  638. X              switch (ptype)
  639. X                {
  640. X                  case '!' : if (pktdone) done = 1 ;
  641. X                             break ;
  642. X                  default  : if (rswstate == ACK || rswstate == NAK) done = 1 ;
  643. X                }
  644. X              if (done) break ;
  645. X            }
  646. X          else break ;
  647. X        }
  648. X      while (!done) ;
  649. X      if (rswstate == ACK) return(0) ;
  650. X    }
  651. X  retval = 4 ;   /* Scanner not responding. Aborting this scan. */
  652. X  CLOSE(rf) ;
  653. X  return(-1) ;
  654. X}
  655. X
  656. X
  657. Xset_signals()   /* Setup a signal handler for a range of signals. */
  658. X{
  659. X  SIGNAL(SIGHUP,  do_exit) ;
  660. X  SIGNAL(SIGQUIT, do_exit) ;
  661. X  SIGNAL(SIGILL,  do_exit) ;
  662. X  SIGNAL(SIGTRAP, do_exit) ;
  663. X  SIGNAL(SIGIOT,  do_exit) ;
  664. X  SIGNAL(SIGEMT,  do_exit) ;
  665. X  SIGNAL(SIGFPE,  do_exit) ;
  666. X  SIGNAL(SIGBUS,  do_exit) ;
  667. X  SIGNAL(SIGSEGV, do_exit) ;
  668. X}
  669. X
  670. X
  671. Xusage()
  672. X{
  673. X  FPRINTF(stderr, "Usage: %s: [-b brightness] [-c contrast] ", progname) ;
  674. X  FPRINTF(stderr, "[-d] [-f x1 y1 x2 y2] [-g grain] [-m] [-p picname]\n") ;
  675. X  FPRINTF(stderr, "[-s] [-t] [-v] [-?] [-Wi] [-Wp x y] [-WP x y]\n") ;
  676. X  exit(5) ;
  677. X}
  678. END_OF_FILE
  679. if test 19805 -ne `wc -c <'scantool/scan.c'`; then
  680.     echo shar: \"'scantool/scan.c'\" unpacked with wrong size!
  681. fi
  682. # end of 'scantool/scan.c'
  683. fi
  684. if test -f 'scantool/sunview.c' -a "${1}" != "-c" ; then 
  685.   echo shar: Will not clobber existing file \"'scantool/sunview.c'\"
  686. else
  687. echo shar: Extracting \"'scantool/sunview.c'\" \(13868 characters\)
  688. sed "s/^X//" >'scantool/sunview.c' <<'END_OF_FILE'
  689. X 
  690. X/*  @(#)sunview.c 1.4 90/04/04
  691. X *
  692. X *  SunView dependent graphics routines used by scantool.
  693. X *
  694. X *  Copyright (c) Rich Burridge.
  695. X *                Sun Microsystems, Australia - All rights reserved.
  696. X *
  697. X *  Permission is given to distribute these sources, as long as the
  698. X *  copyright messages are not removed, and no monies are exchanged.
  699. X *
  700. X *  No responsibility is taken for any errors or inaccuracies inherent
  701. X *  either to the comments or the code of this program, but if
  702. X *  reported to me, then an attempt will be made to fix them.
  703. X */
  704. X
  705. X#include <stdio.h>
  706. X#include <sys/fcntl.h>
  707. X#include <sys/wait.h>
  708. X#include <sys/time.h>
  709. X#include <sys/resource.h>
  710. X#include "scantool.h"
  711. X#include "images.h"
  712. X#include "scantool_extern.h"
  713. X#include <suntool/sunview.h>
  714. X#include <suntool/canvas.h>
  715. X
  716. X#define  MENU_SET                       (void) menu_set
  717. X#define  NOTIFY_DISPATCH                (void) notify_dispatch
  718. X#define  NOTIFY_INTERPOSE_DESTROY_FUNC  (void) notify_interpose_destroy_func
  719. X#define  NOTIFY_INTERPOSE_EVENT_FUNC    (void) notify_interpose_event_func
  720. X#define  NOTIFY_SET_WAIT3_FUNC          (void) notify_set_wait3_func
  721. X#define  PR_DESTROY                     (void) pr_destroy
  722. X#define  PW_REPLROP                     (void) pw_replrop
  723. X#define  PW_ROP                         (void) pw_rop
  724. X#define  PW_TEXT                        (void) pw_text
  725. X#define  PW_TTEXT                       (void) pw_ttext
  726. X#define  PW_VECTOR                      (void) pw_vector
  727. X#define  PW_WRITEBACKGROUND             (void) pw_writebackground
  728. X#define  WINDOW_READ_EVENT              (void) window_read_event
  729. X#define  WINDOW_SET                     (void) window_set
  730. X
  731. X/* Fonts used by scantool. */
  732. X#define  BOLD_FONT      "/usr/lib/fonts/fixedwidthfonts/screen.b.14"
  733. X#define  NORMAL_FONT    "/usr/lib/fonts/fixedwidthfonts/screen.r.14"
  734. X
  735. Xstruct pixfont *open_font() ;
  736. Xvoid repaint_show_canvas() ;
  737. X
  738. XCanvas canvas, show_canvas ;
  739. XCursor cursor[MAXCURSORS] ;
  740. XEvent *cur_event ;
  741. XFrame base_frame, show_frame ;
  742. XIcon scantool_icon ;
  743. XMenu menus[MAXMENUS] ;
  744. XNotify_value destroy(), handle_resize() ;
  745. XPixfont *font[MAXFONTS] ;
  746. XPixrect *images[MAXIMAGES] ;
  747. XPixrect *spr ;
  748. XPixwin *spw, *wpw ;
  749. X
  750. Xint firsttime ;      /* Set if we haven't resized the window yet. */
  751. Xint init_height ;    /* Initial height of the scantool window. */
  752. Xint init_width ;     /* Initial width of the scantool window. */
  753. X
  754. Xstruct rasterfile hdr ;
  755. X
  756. Xmpr_static(grey_pr,          16, 16, 1, grey_image) ;
  757. Xmpr_static(icon_pr,          64, 64, 1, icon_image) ;
  758. Xmpr_static(exclaim_pr,       64, 64, 1, exclaim_image) ;
  759. Xmpr_static(button_normal_pr, 64, 64, 1, button_normal_image) ;
  760. Xmpr_static(button_invert_pr, 64, 64, 1, button_invert_image) ;
  761. Xmpr_static(switch_normal_pr, 16, 16, 1, switch_normal_image) ;
  762. Xmpr_static(switch_invert_pr, 16, 16, 1, switch_invert_image) ;
  763. Xmpr_static(main_cursor_pr,   16, 16, 1, main_cursor_array) ;
  764. Xmpr_static(hour_cursor_pr,   16, 16, 1, hour_cursor_array) ;
  765. Xmpr_static(help_cursor_pr,   16, 16, 1, help_cursor_array) ;
  766. Xmpr_static(frame_cursor_pr,  16, 16, 1, frame_cursor_array) ;
  767. X 
  768. X
  769. X/*ARGSUSED*/
  770. Xvoid
  771. Xcanvas_proc(canvas, event)
  772. XCanvas canvas ;
  773. XEvent *event ;
  774. X{
  775. X  cur_event = event ;
  776. X  handle_event() ;       /* Determine what kind of event it is. */
  777. X  process_event() ;      /* And process it. */
  778. X}
  779. X
  780. Xcreate_menu(mtype, title, values)    /* Create popup menus for cycle items. */
  781. Xenum menu_type mtype ;
  782. Xchar *title, *values[] ;
  783. X{
  784. X  int i = 0 ;
  785. X  int more = 1 ;   /* Cleared when current menu is complete.*/
  786. X
  787. X  menus[(int) mtype] = menu_create(MENU_TITLE_ITEM, title,
  788. X                                   MENU_FONT,       font[(int) NFONT],
  789. X                                   0) ;
  790. X  do
  791. X    {
  792. X      if (values[i] != NULL)
  793. X        MENU_SET(menus[(int) mtype], MENU_STRING_ITEM, values[i], i+1, 0) ;
  794. X      else more = 0 ;
  795. X      i++ ;
  796. X    }
  797. X  while (more) ;
  798. X}
  799. X
  800. X/*ARGSUSED*/
  801. XNotify_value
  802. Xdestroy(client, status)
  803. XNotify_client client ;
  804. XDestroy_status status ;
  805. X{
  806. X  stop_scan() ;        /* Stop the current scan (if there is one). */
  807. X  exit(0) ;
  808. X}
  809. X
  810. Xdisplay_menu(menuno)
  811. Xenum menu_type menuno ;
  812. X{
  813. X  return((int) menu_show(menus[(int) menuno], canvas,
  814. X                         canvas_window_event(canvas, cur_event), 0)) ;
  815. X}
  816. X
  817. Xdraw_area(x, y, width, height, op)
  818. Xint x, y, width, height ;
  819. Xenum op_type op ;
  820. X{
  821. X  PW_WRITEBACKGROUND(wpw, x, y, width, height, ops[(int) op]) ;
  822. X}
  823. X
  824. Xdraw_image(x, y, width, height, image)
  825. Xint x, y, width, height ;
  826. Xenum image_type image ;
  827. X{
  828. X  PW_ROP(wpw, x, y, width, height, PIX_SRC, images[(int) image], 0, 0) ;
  829. X}
  830. X
  831. Xdraw_line(x1, y1, x2, y2, op)
  832. Xint x1, y1, x2, y2 ;
  833. Xenum op_type op ;
  834. X{
  835. X  PW_VECTOR(wpw, x1, y1, x2, y2, ops[(int) op], 1) ;
  836. X}
  837. X
  838. Xdraw_text(x, y, stencil, ftype, str)
  839. Xint x, y ;
  840. Xenum sten_type stencil ;
  841. Xenum font_type ftype ;
  842. Xchar *str ;
  843. X{
  844. X  switch (stencil)
  845. X    {
  846. X      case STEN_OFF : PW_TEXT(wpw,  x, y, PIX_SRC, font[(int) ftype], str) ;
  847. X                      break ;
  848. X      case STEN_ON  : PW_TTEXT(wpw, x, y, PIX_SET, font[(int) ftype], str) ;
  849. X                      break ;
  850. X      case STEN_INV : PW_TTEXT(wpw, x, y, PIX_CLR, font[(int) ftype], str) ;
  851. X    }
  852. X}
  853. X
  854. Xget_event()       /* Get the next SunView event. */
  855. X{
  856. X  WINDOW_READ_EVENT(canvas, cur_event) ;
  857. X}
  858. X
  859. Xget_strwidth(ftype, str)    /* Get width in pixels of string value. */
  860. Xenum font_type ftype ;
  861. Xchar *str ;
  862. X{
  863. X  struct pr_size size ;
  864. X
  865. X  size = pf_textwidth(strlen(str), font[(int) ftype], str) ;
  866. X  return(size.x) ;
  867. X}
  868. X
  869. Xgrey_area(x, y, width, height)
  870. X{
  871. X  PW_REPLROP(wpw, x, y, width, height, PIX_SRC, &grey_pr, 0, 0) ;
  872. X}
  873. X
  874. Xhandle_event()        /* Work out what kind of event this is. */
  875. X{
  876. X  curx = event_x(cur_event) ;
  877. X  cury = event_y(cur_event) ;
  878. X  cur_ch = event_id(cur_event) ;
  879. X
  880. X  if (event_is_button(cur_event) && event_is_down(cur_event))
  881. X    {
  882. X           if (cur_ch == MS_LEFT)     type = LEFT_DOWN ;
  883. X      else if (cur_ch == MS_MIDDLE)   type = MIDDLE_DOWN ;
  884. X      else if (cur_ch == MS_RIGHT)    type = RIGHT_DOWN ;
  885. X    }
  886. X  else if (event_is_button(cur_event) && event_is_up(cur_event))
  887. X    {
  888. X           if (cur_ch == MS_LEFT)     type = LEFT_UP ;
  889. X      else if (cur_ch == MS_MIDDLE)   type = MIDDLE_UP ;
  890. X      else if (cur_ch == MS_RIGHT)    type = RIGHT_UP ;
  891. X    }
  892. X  else if (event_is_ascii(cur_event)) type = KEYBOARD ;
  893. X  else if (cur_ch == LOC_MOVE)        type = MOUSE_MOVE ;
  894. X  else if (cur_ch == LOC_DRAG)        type = MOUSE_DRAG ;
  895. X  else if (cur_ch == WIN_REPAINT)     type = REPAINT ;
  896. X  else                                type = IGNORE ;
  897. X}
  898. X
  899. XNotify_value
  900. Xhandle_resize(frame, event, arg, type)
  901. XFrame frame ;
  902. XEvent *event ;
  903. XNotify_arg arg ;
  904. XNotify_event_type type ;
  905. X{
  906. X  Notify_value value ;
  907. X  Rect *r ;
  908. X
  909. X  value = notify_next_event_func(frame, (Notify_event) event, arg, type) ;
  910. X  if (event_id(event) == WIN_RESIZE)
  911. X    if (firsttime)
  912. X      {
  913. X        init_width = (int) window_get(base_frame, WIN_WIDTH) ;
  914. X        init_height = (int) window_get(base_frame, WIN_HEIGHT) ;
  915. X        firsttime = 0 ;
  916. X      }
  917. X    else
  918. X      {
  919. X        r = (Rect *) LINT_CAST(window_get(frame, WIN_RECT)) ;
  920. X        r->r_width  = init_width ;
  921. X        r->r_height = init_height ;
  922. X        WINDOW_SET(frame, FRAME_OPEN_RECT, r, 0) ;
  923. X        do_repaint() ;
  924. X      }   
  925. X  return(value) ;
  926. X}
  927. X
  928. Xinit_fonts()
  929. X{
  930. X  font[(int) NFONT] = open_font(NORMAL_FONT) ;
  931. X  font_width = font[(int) NFONT]->pf_defaultsize.x ;
  932. X  font[(int) BFONT] = open_font(BOLD_FONT) ;
  933. X}
  934. X
  935. Xinit_ws_type()
  936. X{
  937. X  ops[(int) GSET] = PIX_SET ;
  938. X  ops[(int) GCLR] = PIX_CLR ;
  939. X  ops[(int) GXOR] = PIX_SRC ^ PIX_DST ;
  940. X  ops[(int) GSRC] = PIX_SRC ;
  941. X  ops[(int) GOR]  = PIX_SRC | PIX_DST ;
  942. X  ops[(int) GNOT] = PIX_NOT(PIX_DST) ;
  943. X
  944. X  firsttime = 1 ;
  945. X}
  946. X
  947. Xmake_frames(argc, argv)
  948. Xint argc ;
  949. Xchar *argv[] ;
  950. X{
  951. X  scantool_icon = icon_create(ICON_IMAGE, &icon_pr, 0) ;
  952. X  base_frame = window_create((Window) 0,           FRAME,
  953. X                             FRAME_ICON,           scantool_icon,
  954. X                             FRAME_LABEL,          progname,
  955. X                             FRAME_EMBOLDEN_LABEL, TRUE,
  956. X                             FRAME_ARGS,           argc,argv,
  957. X                             0) ;
  958. X
  959. X  show_frame = window_create(base_frame,       FRAME,
  960. X                             FRAME_SHOW_LABEL, TRUE,
  961. X                             WIN_WIDTH,        650,
  962. X                             WIN_HEIGHT,       900,
  963. X                             WIN_X,            0,
  964. X                             WIN_Y,            0,
  965. X                             WIN_SHOW,         FALSE,
  966. X                             0) ;
  967. X  NOTIFY_INTERPOSE_EVENT_FUNC(base_frame, handle_resize, NOTIFY_SAFE) ;
  968. X}
  969. X
  970. Xmake_subframes()
  971. X{
  972. X  cursor[(int) FRAME_CUR] = cursor_create(CURSOR_IMAGE, &frame_cursor_pr,
  973. X                                          CURSOR_XHOT,  7,
  974. X                                          CURSOR_YHOT,  7,
  975. X                                          0) ;
  976. X  cursor[(int) HELP_CUR]  = cursor_create(CURSOR_IMAGE, &help_cursor_pr, 0) ;
  977. X  cursor[(int) HOUR_CUR]  = cursor_create(CURSOR_IMAGE, &hour_cursor_pr, 0) ;
  978. X  cursor[(int) MAIN_CUR]  = cursor_create(CURSOR_IMAGE, &main_cursor_pr, 0) ;
  979. X 
  980. X  canvas = window_create(base_frame, CANVAS,
  981. X                         WIN_EVENT_PROC,      canvas_proc,
  982. X                         WIN_CURSOR,          cursor[(int) MAIN_CUR],
  983. X                         WIN_WIDTH,           SCAN_WIDTH,
  984. X                         WIN_HEIGHT,          SCAN_HEIGHT,
  985. X                         CANVAS_RETAINED,     FALSE,
  986. X                         CANVAS_FIXED_IMAGE,  FALSE,
  987. X                         0) ;
  988. X  WINDOW_SET(canvas, WIN_CONSUME_KBD_EVENTS, WIN_ASCII_EVENTS,
  989. X                     WIN_UP_EVENTS, 0, 0) ;
  990. X  WINDOW_SET(canvas, WIN_CONSUME_PICK_EVENTS, LOC_DRAG, LOC_MOVE, 0, 0) ;
  991. X  wpw = canvas_pixwin(canvas) ;
  992. X
  993. X  show_canvas = window_create(show_frame, CANVAS,
  994. X                              CANVAS_REPAINT_PROC, repaint_show_canvas,
  995. X                              0) ;
  996. X  spw = canvas_pixwin(show_canvas) ;
  997. X  spr = NULL ;
  998. X
  999. X  images[(int) B_NORMAL]      = &button_normal_pr ;
  1000. X  images[(int) B_INVERT]      = &button_invert_pr ;
  1001. X  images[(int) S_NORMAL]      = &switch_normal_pr ;
  1002. X  images[(int) S_INVERT]      = &switch_invert_pr ;
  1003. X  images[(int) EXCLAIM_IMAGE] = &exclaim_pr ;
  1004. X}
  1005. X
  1006. XPixfont *
  1007. Xopen_font(fontname)
  1008. Xchar *fontname ;
  1009. X{
  1010. X  Pixfont *f ;
  1011. X
  1012. X  if ((f = pf_open(fontname)) == NULL)
  1013. X    if ((f = pf_default()) == NULL)
  1014. X      {
  1015. X        perror("couldn't get the default font.") ;
  1016. X        exit(1) ;
  1017. X      }
  1018. X  return(f) ;
  1019. X}
  1020. X
  1021. X/*ARGSUSED*/
  1022. Xvoid
  1023. Xrepaint_show_canvas(canvas, pw, repaint_area)     /* Show current picture. */
  1024. XCanvas canvas ;
  1025. XPixwin *pw ;
  1026. XRectlist *repaint_area ;
  1027. X{
  1028. X  PW_ROP(pw, 0, 0, hdr.ras_width, hdr.ras_height, PIX_SRC, spr, 0, 0) ;
  1029. X}
  1030. X
  1031. Xset_cursor(ctype)
  1032. Xenum cur_type ctype ;
  1033. X{
  1034. X  WINDOW_SET(canvas, WIN_CURSOR, cursor[(int) ctype], 0) ;
  1035. X}
  1036. X
  1037. Xshow()      /* Display scanned image. */
  1038. X{
  1039. X  Rect *temprect ;
  1040. X  char errmes[MAXLINE] ;
  1041. X  int fd ;
  1042. X
  1043. X  showing = 1 ;
  1044. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+100, "Show", B_INVERT) ;
  1045. X  if (spr) PR_DESTROY(spr) ;
  1046. X  if ((fd = open(picname, O_RDONLY | O_NDELAY, 0644)) == -1)
  1047. X    {
  1048. X      SPRINTF(errmes, "Cannot open %s.", picname) ;
  1049. X      make_display(errmes) ;
  1050. X    }
  1051. X  else
  1052. X    { 
  1053. X      READ(fd, (char *) &hdr, sizeof(struct rasterfile)) ;
  1054. X      if (hdr.ras_maplength)
  1055. X        {
  1056. X          make_display("Color rasterfiles currently not supported.") ;
  1057. X          return ;
  1058. X        }
  1059. X      spr = mem_create(hdr.ras_width, hdr.ras_height, hdr.ras_depth) ;
  1060. X      READ(fd, (char *) (mpr_d(spr)->md_image),
  1061. X           hdr.ras_width * hdr.ras_height) ;
  1062. X      CLOSE(fd) ;
  1063. X      temprect = (Rect *) LINT_CAST(window_get(show_frame, FRAME_OPEN_RECT)) ;
  1064. X      temprect->r_left = temprect->r_top = 0 ;
  1065. X      temprect->r_height = hdr.ras_height ;
  1066. X      temprect->r_width = hdr.ras_width ;
  1067. X      WINDOW_SET(show_frame, FRAME_OPEN_RECT, temprect, 0) ;
  1068. X      WINDOW_SET(show_frame, FRAME_LABEL, picname, 0) ;
  1069. X      WINDOW_SET(show_frame, WIN_SHOW, TRUE, 0) ;
  1070. X    }
  1071. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+100, "Show", B_NORMAL) ;
  1072. X  showing = 0 ;
  1073. X}
  1074. X
  1075. Xstart_tool()
  1076. X{
  1077. X  window_fit(base_frame) ;
  1078. X  NOTIFY_INTERPOSE_DESTROY_FUNC(base_frame, destroy) ;
  1079. X  window_main_loop(base_frame) ;
  1080. X}
  1081. X
  1082. X/*ARGSUSED*/
  1083. XNotify_value
  1084. Xwait_child(frame, pid, status, rusage)
  1085. XWindow frame ;
  1086. Xint pid ;
  1087. Xunion wait *status ;
  1088. Xstruct rusage *rusage ;
  1089. X{
  1090. X  char output[MAXLINE] ;
  1091. X  int high, low ;
  1092. X
  1093. X  if (WIFSTOPPED(*status)) return (NOTIFY_IGNORED) ;
  1094. X
  1095. X  high = (status->w_status & 0xFF00) >> 8 ;
  1096. X  low = status->w_status & 0xFF ;
  1097. X  if (low) SPRINTF(output, "Scan: terminated with signal %1d", (low & 0x3F)) ;
  1098. X  else
  1099. X    {
  1100. X      switch (high)
  1101. X        {
  1102. X          case 0  : SPRINTF(output, "Scan: successful. %s saved",
  1103. X                                     picname) ;
  1104. X                    break ;
  1105. X          case 1  : SPRINTF(output, "Scan: cannot open tty port %c",
  1106. X                                     switches[SERIAL_PORT] + 'A') ;
  1107. X                    break ;
  1108. X          case 2  : SPRINTF(output, "Scan: cannot open temporary image file") ;
  1109. X                    break ;
  1110. X          case 3  : SPRINTF(output, "Scan: cannot open raster header file") ;
  1111. X                    break ;
  1112. X          case 4  : SPRINTF(output, "Scan: scanner not responding; aborting") ;
  1113. X                    break ;
  1114. X          case 5  : SPRINTF(output, "Scan: invalid command line argument") ;
  1115. X                    break ;
  1116. X          default : if (high >= 100 && high < 200)
  1117. X                      SPRINTF(output, "Scan: scanner error %1d; aborting",
  1118. X                                       high - 100) ;
  1119. X                    else
  1120. X                      SPRINTF(output, "Scan: terminated with signal %1d",
  1121. X                                       high - 200) ;
  1122. X        }
  1123. X    }
  1124. X  make_display(output) ;
  1125. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+20, "Scan",   B_NORMAL) ;
  1126. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+60, "Cancel", B_NORMAL) ;
  1127. X  scanning = 0 ;
  1128. X  return (NOTIFY_DONE) ;
  1129. X}
  1130. X
  1131. Xwait_on_child(pid)      /* Wait on child scan process. */
  1132. Xint pid ;
  1133. X{
  1134. X  NOTIFY_SET_WAIT3_FUNC(base_frame, wait_child, pid) ;
  1135. X}
  1136. END_OF_FILE
  1137. if test 13868 -ne `wc -c <'scantool/sunview.c'`; then
  1138.     echo shar: \"'scantool/sunview.c'\" unpacked with wrong size!
  1139. fi
  1140. # end of 'scantool/sunview.c'
  1141. fi
  1142. if test -f 'scantool/switch.normal.cursor' -a "${1}" != "-c" ; then 
  1143.   echo shar: Will not clobber existing file \"'scantool/switch.normal.cursor'\"
  1144. else
  1145. echo shar: Extracting \"'scantool/switch.normal.cursor'\" \(193 characters\)
  1146. sed "s/^X//" >'scantool/switch.normal.cursor' <<'END_OF_FILE'
  1147. X/* Format_version=1, Width=16, Height=16, Depth=1, Valid_bits_per_item=16
  1148. X */
  1149. X    0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0xFFE0,0x8020,
  1150. X    0x8020,0x8020,0x8020,0x8020,0x8020,0x8020,0x8020,0xFFE0
  1151. END_OF_FILE
  1152. if test 193 -ne `wc -c <'scantool/switch.normal.cursor'`; then
  1153.     echo shar: \"'scantool/switch.normal.cursor'\" unpacked with wrong size!
  1154. fi
  1155. # end of 'scantool/switch.normal.cursor'
  1156. fi
  1157. if test -f 'scantool/xview.c' -a "${1}" != "-c" ; then 
  1158.   echo shar: Will not clobber existing file \"'scantool/xview.c'\"
  1159. else
  1160. echo shar: Extracting \"'scantool/xview.c'\" \(16921 characters\)
  1161. sed "s/^X//" >'scantool/xview.c' <<'END_OF_FILE'
  1162. X
  1163. X/*  @(#)xview.c 1.5 90/04/10
  1164. X *
  1165. X *  XView dependent graphics routines used by scantool.
  1166. X *
  1167. X *  Copyright (c) Rich Burridge.
  1168. X *                Sun Microsystems, Australia - All rights reserved.
  1169. X *
  1170. X *  Permission is given to distribute these sources, as long as the
  1171. X *  copyright messages are not removed, and no monies are exchanged.
  1172. X *
  1173. X *  No responsibility is taken for any errors or inaccuracies inherent
  1174. X *  either to the comments or the code of this program, but if
  1175. X *  reported to me, then an attempt will be made to fix them.
  1176. X */
  1177. X
  1178. X#include <stdio.h>
  1179. X#include <sys/fcntl.h>
  1180. X#include <sys/wait.h>
  1181. X#include <sys/time.h>
  1182. X#include <sys/resource.h>
  1183. X#include "scantool.h"
  1184. X#include "scantool_extern.h"
  1185. X#include "images.h"
  1186. X#include <rasterfile.h>
  1187. X#include <xview/xview.h>
  1188. X#include <xview/canvas.h>
  1189. X#include <xview/font.h>
  1190. X#include <xview/fullscreen.h>
  1191. X#include <xview/cursor.h>
  1192. X#include <xview/svrimage.h>
  1193. X#include <X11/Xlib.h>
  1194. X
  1195. X#define  NOTIFY_INTERPOSE_DESTROY_FUNC  (void) notify_interpose_destroy_func
  1196. X#define  NOTIFY_SET_SIGNAL_FUNC         (void) notify_set_signal_func
  1197. X#define  NOTIFY_SET_WAIT3_FUNC          (void) notify_set_wait3_func
  1198. X#define  PR_DESTROY                     (void) pr_destroy
  1199. X#define  PW_WRITE                       (void) pw_write
  1200. X#define  XV_INPUT_READEVENT             (void) xv_input_readevent
  1201. X#define  XV_SET                         (void) xv_set
  1202. X
  1203. X#define  BOLDFONT    "lucidasanstypewriter-bold-12"
  1204. X#define  DEFFONT     "fixed"
  1205. X#define  NORMALFONT  "lucidasanstypewriter-12"
  1206. X
  1207. Xint menu_proc() ;
  1208. Xvoid repaint_show_canvas() ;
  1209. X
  1210. XCanvas canvas, show_canvas ;
  1211. XCanvas_paint_window spw, wpw ;
  1212. XEvent *cur_event ;
  1213. XFrame base_frame, show_frame ;
  1214. XFullscreen fs ;
  1215. XIcon scantool_icon ;
  1216. XMenu menus[MAXMENUS] ;
  1217. XNotify_value destroy() ;
  1218. XPixrect *spr ;
  1219. XServer_image frame_cursor_pr, help_cursor_pr, hour_cursor_pr, main_cursor_pr ;
  1220. XServer_image make_server_image() ;
  1221. X
  1222. XXv_cursor cursor[MAXCURSORS] ;
  1223. X
  1224. XDisplay *dpy ;                  /* Display id of scantool frame. */
  1225. XDrawable xid ;                  /* Xid for scantool canvas. */
  1226. XDrawable grey_pr ;
  1227. XDrawable images[MAXIMAGES] ;    /* Xids for various graphical images. */
  1228. XGC backgc ;                     /* Graphics context for pw_writebackground. */
  1229. XGC gc ;                         /* Graphics context for text and lines. */
  1230. XGC ropgc ;                      /* Graphics context for rops. */
  1231. XWindow root ;
  1232. XXFontStruct *font[MAXFONTS] ;   /* Xlib handles to the fonts. */
  1233. XXGCValues gc_val ;              /* Used to setup graphics context values. */
  1234. Xint gc_flags ;                  /* Used to set up graphics context flags. */
  1235. Xint screen ;                    /* Default graphics display screen. */
  1236. Xunsigned long backgnd ;         /* Default background color. */
  1237. Xunsigned long foregnd ;         /* Default foreground color. */
  1238. Xunsigned long gc_mask ;         /* Mask for setting graphic context values. */
  1239. X
  1240. Xenum menu_type cur_menu ;     /* Current menu type being processed. */
  1241. X
  1242. Xint init_height ;             /* Initial height of the scantool window. */
  1243. Xint init_width ;              /* Initial width of the scantool window. */
  1244. Xint started ;                 /* Kludge to correct handle repaints. */
  1245. X
  1246. Xstruct rasterfile hdr ;
  1247. X
  1248. Xmpr_static(icon_pr, 64, 64, 1, icon_image) ;
  1249. X
  1250. X/*ARGSUSED*/
  1251. Xvoid
  1252. Xcanvas_proc(canvas, event)
  1253. XCanvas canvas ;
  1254. XEvent *event ;
  1255. X{
  1256. X  if (!started) return ;
  1257. X  cur_event = event ;
  1258. X  handle_event() ;       /* Determine what kind of event it is. */
  1259. X  process_event() ;      /* And process it. */
  1260. X}
  1261. X
  1262. Xcreate_menu(mtype, title, values)    /* Create popup menus for cycle items. */
  1263. Xenum menu_type mtype ;
  1264. Xchar *title, *values[] ;
  1265. X{
  1266. X  int i = 0 ;
  1267. X  int more = 1 ;   /* Cleared when current menu is complete.*/
  1268. X
  1269. X  menus[(int) mtype] = xv_create(XV_NULL,          MENU_COMMAND_MENU,
  1270. X                                 MENU_NOTIFY_PROC, menu_proc,
  1271. X                                 MENU_TITLE_ITEM,  title,
  1272. X                                 0) ;
  1273. X  do
  1274. X    {
  1275. X      if (values[i] != NULL)
  1276. X        XV_SET(menus[(int) mtype], MENU_STRING_ITEM, values[i], i+1, 0) ;
  1277. X      else more = 0 ;
  1278. X      i++ ;
  1279. X    }
  1280. X  while (more) ;
  1281. X}
  1282. X
  1283. XNotify_value
  1284. Xdestroy(client, status)
  1285. XNotify_client client ;
  1286. XDestroy_status status ;
  1287. X{
  1288. X  stop_scan() ;        /* Stop the current scan (if there is one). */
  1289. X  exit(0) ;
  1290. X}
  1291. X
  1292. Xdisplay_menu(menuno)
  1293. Xenum menu_type menuno ;
  1294. X{
  1295. X  cur_menu = menuno ;
  1296. X  menu_show(menus[(int) menuno], canvas, cur_event, 0) ;
  1297. X  return(0) ;
  1298. X}
  1299. X
  1300. Xdraw_area(x, y, width, height, op)
  1301. Xint x, y, width, height ;
  1302. Xenum op_type op ;
  1303. X{
  1304. X  if (op == GNOT)
  1305. X    {
  1306. X      XSetFunction(dpy, gc, GXcopyInverted) ;
  1307. X      XCopyArea(dpy, xid, xid, gc, x, y, width, height, x, y) ;
  1308. X    }
  1309. X  else
  1310. X    {
  1311. X      XSetFunction(dpy, backgc, ops[(int) op]) ;
  1312. X      XFillRectangle(dpy, xid, backgc, x, y, width, height) ;
  1313. X    }
  1314. X}
  1315. X
  1316. Xdraw_image(x, y, width, height, image)
  1317. Xint x, y, width, height ;
  1318. Xenum image_type image ;
  1319. X{
  1320. X  gc_mask = GCStipple | GCTileStipXOrigin | GCTileStipYOrigin ;
  1321. X  gc_val.stipple = images[(int) image] ;
  1322. X  gc_val.ts_x_origin = x ;
  1323. X  gc_val.ts_y_origin = y ;
  1324. X  XChangeGC(dpy, ropgc, gc_mask, &gc_val) ;
  1325. X  XFillRectangle(dpy, xid, ropgc, x, y, width, height) ;
  1326. X}
  1327. X
  1328. Xdraw_line(x1, y1, x2, y2, op)
  1329. Xint x1, y1, x2, y2 ;
  1330. Xenum op_type op ;
  1331. X{
  1332. X  gc_val.foreground = foregnd ;
  1333. X  gc_val.function = ops[(int) op] ;
  1334. X  XChangeGC(dpy, gc, GCForeground | GCFunction, &gc_val) ;
  1335. X  XDrawLine(dpy, xid, gc, x1, y1, x2, y2) ;
  1336. X}
  1337. X
  1338. X/*ARGSUSED*/
  1339. Xdraw_text(x, y, stencil, ftype, str)
  1340. Xint x, y ;
  1341. Xenum sten_type stencil ;
  1342. Xenum font_type ftype ;
  1343. Xchar *str ;
  1344. X{
  1345. X  gc_val.foreground = foregnd ;
  1346. X  gc_val.font = font[(int) ftype]->fid ;
  1347. X  if (stencil == STEN_INV) gc_val.function = GXcopyInverted ;
  1348. X  else                     gc_val.function = GXcopy ;
  1349. X  XChangeGC(dpy, gc, GCFont | GCForeground | GCFunction, &gc_val) ;
  1350. X  XDrawString(dpy, xid, gc, x, y, str, strlen(str)) ;
  1351. X}
  1352. X
  1353. Xget_event()       /* Get the next XView event. */
  1354. X{
  1355. X  XV_INPUT_READEVENT(wpw, cur_event, 1, 0, NULL) ;
  1356. X  if (event_is_button(cur_event))
  1357. X    if (event_is_down(cur_event))
  1358. X      fs = xv_create(wpw, FULLSCREEN,
  1359. X                     WIN_CONSUME_EVENTS,
  1360. X                       WIN_MOUSE_BUTTONS, LOC_DRAG, 0,
  1361. X                     0) ;
  1362. X    else if (event_is_up(cur_event)) xv_destroy(fs) ;
  1363. X}
  1364. X
  1365. XXFontStruct *
  1366. Xget_font(name)
  1367. Xchar *name ;
  1368. X{
  1369. X  XFontStruct *f ;
  1370. X 
  1371. X  if (!(f = XLoadQueryFont(dpy, name)))
  1372. X    if (!(f = XLoadQueryFont(dpy, DEFFONT)))
  1373. X      {
  1374. X        FPRINTF(stderr, "%s: couldn't get the default font.", progname) ;
  1375. X        exit(1) ;
  1376. X      }
  1377. X  return(f) ;
  1378. X}
  1379. X
  1380. Xget_strwidth(ftype, str)    /* Get width in pixels of string value. */
  1381. Xenum font_type ftype ;
  1382. Xchar *str ;
  1383. X{
  1384. X  return(XTextWidth(font[(int) ftype], str, strlen(str))) ;
  1385. X}
  1386. X
  1387. Xgrey_area(x, y, width, height)
  1388. X{
  1389. X  gc_mask = GCStipple | GCTileStipXOrigin | GCTileStipYOrigin ;
  1390. X  gc_val.stipple = grey_pr ;
  1391. X  gc_val.ts_x_origin = x % 16 ;
  1392. X  gc_val.ts_y_origin = y % 16 ;
  1393. X  XChangeGC(dpy, ropgc, gc_mask, &gc_val) ;
  1394. X  XFillRectangle(dpy, xid, ropgc, x, y, width, height) ;
  1395. X}
  1396. X
  1397. Xhandle_event()        /* Work out what kind of event this is. */
  1398. X{
  1399. X  curx = event_x(cur_event) ;
  1400. X  cury = event_y(cur_event) ;
  1401. X  cur_ch = event_id(cur_event) ;
  1402. X
  1403. X       if (cur_ch == LOC_WINENTER)   win_set_kbd_focus(canvas, xid) ;
  1404. X  else if (cur_ch == WIN_REPAINT)    type = REPAINT ;
  1405. X  else if (cur_ch == LOC_MOVE)       type = MOUSE_MOVE ;
  1406. X  else if (cur_ch == LOC_DRAG)       type = MOUSE_DRAG ;
  1407. X  else if (event_is_button(cur_event) && event_is_down(cur_event))
  1408. X    {
  1409. X           if (cur_ch == MS_LEFT)    type = LEFT_DOWN ;
  1410. X      else if (cur_ch == MS_MIDDLE)  type = MIDDLE_DOWN ;
  1411. X      else if (cur_ch == MS_RIGHT)   type = RIGHT_DOWN ;
  1412. X    }
  1413. X  else if (event_is_button(cur_event) && event_is_up(cur_event))
  1414. X    {
  1415. X           if (cur_ch == MS_LEFT)    type = LEFT_UP ;
  1416. X      else if (cur_ch == MS_MIDDLE)  type = MIDDLE_UP ;
  1417. X      else if (cur_ch == MS_RIGHT)   type = RIGHT_UP ;
  1418. X    }
  1419. X  else if (event_is_ascii(cur_event) &&
  1420. X           event_is_down(cur_event)) type = KEYBOARD ;
  1421. X  else                               type = IGNORE ;
  1422. X}
  1423. X
  1424. Xinit_fonts()
  1425. X{
  1426. X  font[(int) NFONT] = get_font(NORMALFONT) ;
  1427. X  font_width = font[(int) NFONT]->max_bounds.rbearing -
  1428. X               font[(int) NFONT]->min_bounds.lbearing ;
  1429. X  font[(int) BFONT] = get_font(BOLDFONT) ;
  1430. X}
  1431. X
  1432. Xinit_ws_type()
  1433. X{
  1434. X  ops[(int) GSET] = GXset ;
  1435. X  ops[(int) GCLR] = GXclear ;
  1436. X  ops[(int) GXOR] = GXxor ;
  1437. X  ops[(int) GSRC] = GXcopy ;
  1438. X  ops[(int) GOR]  = GXor ;
  1439. X  ops[(int) GNOT] = GXcopyInverted ;
  1440. X
  1441. X  started = 0 ;      /* Kludge to correctly handle repaints. */
  1442. X}
  1443. X
  1444. Xmake_frames(argc, argv)
  1445. Xint argc ;
  1446. Xchar *argv[] ;
  1447. X{
  1448. X  xv_init(XV_INIT_ARGS, argc, argv, 0) ;
  1449. X  scantool_icon = xv_create(XV_NULL, ICON,
  1450. X                            ICON_IMAGE, &icon_pr,
  1451. X                            0) ;
  1452. X  base_frame = xv_create(XV_NULL,                     FRAME,
  1453. X                         FRAME_ICON,                  scantool_icon,
  1454. X                         FRAME_LABEL,                 progname,
  1455. X                         FRAME_SHOW_RESIZE_CORNER,    FALSE,
  1456. X                         0) ;
  1457. X
  1458. X  show_frame = xv_create(base_frame, FRAME,
  1459. X                         FRAME_SHOW_LABEL, TRUE,
  1460. X                         XV_WIDTH,         650,
  1461. X                         XV_HEIGHT,        900,
  1462. X                         XV_X,             0,
  1463. X                         XV_Y,             0,
  1464. X                         XV_SHOW,          FALSE,
  1465. X                         0) ;
  1466. X}
  1467. X
  1468. Xmake_subframes()
  1469. X{
  1470. X  canvas = xv_create(base_frame,         CANVAS,
  1471. X                     CANVAS_RETAINED,    FALSE,
  1472. X                     OPENWIN_AUTO_CLEAR, FALSE,
  1473. X                     XV_WIDTH,           SCAN_WIDTH,
  1474. X                     XV_HEIGHT,          SCAN_HEIGHT,
  1475. X                     CANVAS_PAINTWINDOW_ATTRS,
  1476. X                       WIN_CONSUME_EVENTS,
  1477. X                         MS_LEFT, MS_MIDDLE, MS_RIGHT,
  1478. X                         WIN_ASCII_EVENTS, KBD_USE, KBD_DONE,
  1479. X                         LOC_WINENTER, LOC_WINEXIT, LOC_DRAG, LOC_MOVE,
  1480. X                         WIN_LEFT_KEYS, WIN_TOP_KEYS, WIN_RIGHT_KEYS,
  1481. X                         WIN_REPAINT,
  1482. X                       0,
  1483. X                       WIN_EVENT_PROC,   canvas_proc,
  1484. X                       0,
  1485. X                     0) ;
  1486. X  wpw = canvas_paint_window(canvas) ;
  1487. X 
  1488. X  dpy = (Display *) xv_get(base_frame, XV_DISPLAY) ;
  1489. X  xid = (Drawable) xv_get(wpw, XV_XID) ;
  1490. X 
  1491. X  screen = DefaultScreen(dpy) ;
  1492. X  root = RootWindow(dpy, screen) ;
  1493. X  foregnd = BlackPixel(dpy, screen) ;
  1494. X  backgnd = WhitePixel(dpy, screen) ;
  1495. X 
  1496. X  gc_mask = GCForeground | GCBackground | GCGraphicsExposures ;
  1497. X  gc_val.foreground = foregnd ;
  1498. X  gc_val.background = backgnd ;
  1499. X  gc_val.graphics_exposures = False ;
  1500. X  gc = XCreateGC(dpy, root, gc_mask, &gc_val) ;
  1501. X
  1502. X  backgc = XCreateGC(dpy, root, gc_mask, &gc_val) ;
  1503. X  XSetForeground(dpy, backgc, gc_val.background) ;
  1504. X
  1505. X  ropgc = XCreateGC(dpy, root, gc_mask, &gc_val) ;
  1506. X  gc_val.function = GXcopy ;
  1507. X  gc_val.fill_style = FillOpaqueStippled ;
  1508. X  XChangeGC(dpy, ropgc, GCFunction | GCFillStyle, &gc_val) ;
  1509. X
  1510. X  grey_pr = (Drawable) xv_get(make_server_image(grey_image, 16, 16), XV_XID) ;
  1511. X  frame_cursor_pr = make_server_image(frame_cursor_array, 16, 16) ;
  1512. X  help_cursor_pr  = make_server_image(help_cursor_array,  16, 16) ;
  1513. X  hour_cursor_pr  = make_server_image(hour_cursor_array,  16, 16) ;
  1514. X  main_cursor_pr  = make_server_image(main_cursor_array,  16, 16) ;
  1515. X  images[(int) B_NORMAL] = (Drawable)
  1516. X               xv_get(make_server_image(button_normal_image, 64, 64), XV_XID) ;
  1517. X  images[(int) B_INVERT] = (Drawable)
  1518. X               xv_get(make_server_image(button_invert_image, 64, 64), XV_XID) ;
  1519. X  images[(int) S_NORMAL] = (Drawable)
  1520. X               xv_get(make_server_image(switch_normal_image, 16, 16), XV_XID) ;
  1521. X  images[(int) S_INVERT] = (Drawable)
  1522. X               xv_get(make_server_image(switch_invert_image, 16, 16), XV_XID) ;
  1523. X  images[(int) EXCLAIM_IMAGE] = (Drawable)
  1524. X               xv_get(make_server_image(exclaim_image, 64, 64), XV_XID) ;
  1525. X
  1526. X  cursor[(int) FRAME_CUR] = xv_create(XV_NULL,      CURSOR,
  1527. X                                      CURSOR_IMAGE, frame_cursor_pr,
  1528. X                                      CURSOR_XHOT,  7,
  1529. X                                      CURSOR_YHOT,  7,
  1530. X                                      0) ;
  1531. X  cursor[(int) HELP_CUR] = xv_create(XV_NULL,      CURSOR,
  1532. X                                     CURSOR_IMAGE, help_cursor_pr,
  1533. X                                     0) ;
  1534. X  cursor[(int) HOUR_CUR] = xv_create(XV_NULL,      CURSOR,
  1535. X                                     CURSOR_IMAGE, hour_cursor_pr,
  1536. X                                     0) ;
  1537. X  cursor[(int) MAIN_CUR] = xv_create(XV_NULL,      CURSOR,
  1538. X                                     CURSOR_IMAGE, main_cursor_pr,
  1539. X                                     0) ;
  1540. X
  1541. X  show_canvas = xv_create(show_frame, CANVAS,
  1542. X                          CANVAS_REPAINT_PROC, repaint_show_canvas,
  1543. X                          0) ;
  1544. X  spw = canvas_paint_window(show_canvas) ;
  1545. X  spr = NULL ;
  1546. X
  1547. X  XV_SET(canvas, WIN_CURSOR, cursor[(int) MAIN_CUR]) ;
  1548. X}
  1549. X
  1550. Xmenu_proc(menu, menu_item)
  1551. XMenu menu ;
  1552. XMenu_item menu_item ;
  1553. X{
  1554. X  int choice ;
  1555. X
  1556. X  choice = (int) menu_get(menu_item, MENU_VALUE) ;
  1557. X  if (choice) process_menu(cur_menu, choice) ;
  1558. X}
  1559. X
  1560. XServer_image
  1561. Xmake_server_image(image, width, height)
  1562. Xunsigned short image[] ;
  1563. Xint width, height ;
  1564. X{
  1565. X  return(xv_create(XV_NULL,           SERVER_IMAGE,
  1566. X                   XV_WIDTH,          width,
  1567. X                   XV_HEIGHT,         height,
  1568. X                   SERVER_IMAGE_BITS, image,
  1569. X                   0)) ;
  1570. X}
  1571. X
  1572. X/*ARGSUSED*/
  1573. Xvoid
  1574. Xrepaint_show_canvas(canvas, pw, repaint_area)     /* Show current picture. */
  1575. XCanvas canvas ;
  1576. XPixwin *pw ;
  1577. XRectlist *repaint_area ;
  1578. X{
  1579. X  PW_WRITE(pw, 0, 0, hdr.ras_width, hdr.ras_height, PIX_SRC, spr, 0, 0) ;
  1580. X}
  1581. X
  1582. Xset_cursor(ctype)
  1583. Xenum cur_type ctype ;
  1584. X{
  1585. X  XV_SET(wpw, WIN_CURSOR, cursor[(int) ctype], 0) ;
  1586. X}
  1587. X
  1588. Xshow()      /* Display scanned image. */
  1589. X{
  1590. X  Rect *temprect ;
  1591. X  char errmes[MAXLINE] ;
  1592. X  int fd ;
  1593. X
  1594. X  showing = 1 ;
  1595. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+100, "Show", B_INVERT) ;
  1596. X  if (spr) PR_DESTROY(spr) ;
  1597. X  if ((fd = open(picname, O_RDONLY | O_NDELAY, 0644)) == -1)
  1598. X    {
  1599. X      SPRINTF(errmes, "Cannot open %s.", picname) ;
  1600. X      make_display(errmes) ;
  1601. X    }
  1602. X  else
  1603. X    { 
  1604. X      READ(fd, (char *) &hdr, sizeof(struct rasterfile)) ;
  1605. X      if (hdr.ras_maplength)
  1606. X        {
  1607. X          make_display("Color rasterfiles currently not supported.") ;
  1608. X          return ;
  1609. X        }
  1610. X      spr = mem_create(hdr.ras_width, hdr.ras_height, hdr.ras_depth) ;
  1611. X      READ(fd, (char *) (mpr_d(spr)->md_image),
  1612. X           hdr.ras_width * hdr.ras_height) ;
  1613. X      CLOSE(fd) ;
  1614. X      temprect = (Rect *) xv_get(show_frame, FRAME_OPEN_RECT) ;
  1615. X      temprect->r_left = temprect->r_top = 0 ;
  1616. X      temprect->r_height = hdr.ras_height ;
  1617. X      temprect->r_width = hdr.ras_width ;
  1618. X      XV_SET(show_frame, FRAME_OPEN_RECT, temprect, 0) ;
  1619. X      XV_SET(show_frame, FRAME_LABEL, picname, 0) ;
  1620. X      XV_SET(show_frame, XV_SHOW, TRUE, 0) ;
  1621. X    }
  1622. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+100, "Show", B_NORMAL) ;
  1623. X  showing = 0 ;
  1624. X}
  1625. X
  1626. Xstart_tool()
  1627. X{
  1628. X  window_fit(base_frame) ;
  1629. X  NOTIFY_INTERPOSE_DESTROY_FUNC(base_frame, destroy) ;
  1630. X  started = 1 ;
  1631. X  window_main_loop(base_frame) ;
  1632. X}
  1633. X
  1634. X/*ARGSUSED*/
  1635. XNotify_value
  1636. Xwait_child(frame, pid, status, rusage)
  1637. XWindow frame ;
  1638. Xint pid ;
  1639. Xunion wait *status ;
  1640. Xstruct rusage *rusage ;
  1641. X{
  1642. X  char output[MAXLINE] ;
  1643. X  int high, low ;
  1644. X
  1645. X  if (WIFSTOPPED(*status)) return (NOTIFY_IGNORED) ;
  1646. X       
  1647. X  high = (status->w_status & 0xFF00) >> 8 ;
  1648. X  low = status->w_status & 0xFF ;
  1649. X  if (low) SPRINTF(output, "Scan: terminated with signal %1d", (low & 0x3F)) ;
  1650. X  else 
  1651. X    {
  1652. X      switch (high)
  1653. X        {
  1654. X          case 0  : SPRINTF(output, "Scan: successful. %s saved",
  1655. X                                     picname) ;
  1656. X                    break ;
  1657. X          case 1  : SPRINTF(output, "Scan: cannot open tty port %c",
  1658. X                                     switches[SERIAL_PORT] + 'A') ;
  1659. X                    break ;
  1660. X          case 2  : SPRINTF(output, "Scan: cannot open temporary image file") ;
  1661. X                    break ;
  1662. X          case 3  : SPRINTF(output, "Scan: cannot open raster header file") ;
  1663. X                    break ;
  1664. X          case 4  : SPRINTF(output, "Scan: scanner not responding; aborting") ;
  1665. X                    break ;
  1666. X          case 5  : SPRINTF(output, "Scan: invalid command line argument") ;
  1667. X                    break ;
  1668. X          default : if (high >= 100 && high < 200)
  1669. X                      SPRINTF(output, "Scan: scanner error %1d; aborting",
  1670. X                                       high - 100) ;
  1671. X                    else
  1672. X                      SPRINTF(output, "Scan: terminated with signal %1d",
  1673. X                                       high - 200) ;
  1674. X        }
  1675. X    }    
  1676. X  make_display(output) ;
  1677. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+20, "Scan",   B_NORMAL) ;
  1678. X  make_button(SCAN_WIDTH-150, 4*SWITCH_HEIGHT+60, "Cancel", B_NORMAL) ;
  1679. X  scanning = 0 ;
  1680. X  return (NOTIFY_DONE) ;
  1681. X}
  1682. X
  1683. Xwait_on_child(pid)      /* Wait on child scan process. */
  1684. Xint pid ;
  1685. X{
  1686. X  NOTIFY_SET_WAIT3_FUNC(base_frame, wait_child, pid) ;
  1687. X}
  1688. END_OF_FILE
  1689. if test 16921 -ne `wc -c <'scantool/xview.c'`; then
  1690.     echo shar: \"'scantool/xview.c'\" unpacked with wrong size!
  1691. fi
  1692. # end of 'scantool/xview.c'
  1693. fi
  1694. echo shar: End of archive 1 \(of 3\).
  1695. cp /dev/null ark1isdone
  1696. MISSING=""
  1697. for I in 1 2 3 ; do
  1698.     if test ! -f ark${I}isdone ; then
  1699.     MISSING="${MISSING} ${I}"
  1700.     fi
  1701. done
  1702. if test "${MISSING}" = "" ; then
  1703.     echo You have unpacked all 3 archives.
  1704.     rm -f ark[1-9]isdone
  1705. else
  1706.     echo You still need to unpack the following archives:
  1707.     echo "        " ${MISSING}
  1708. fi
  1709. ##  End of shell archive.
  1710. exit 0
  1711. dan
  1712. -----------------------------------------------------------
  1713.             O'Reilly && Associates
  1714.         argv@sun.com / argv@ora.com
  1715.        632 Petaluma Ave, Sebastopol, CA 95472 
  1716.      800-338-NUTS, in CA: 800-533-NUTS, FAX 707-829-0104
  1717.     Opinions expressed reflect those of the author only.
  1718.