home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2983 < prev    next >
Encoding:
Internet Message Format  |  1991-03-05  |  55.0 KB
  1. From: matthew@sunpix.East.Sun.COM (Matthew Stier - Sun Visualization Products)
  2. Newsgroups: alt.sources
  3. Subject: Vue, a Sunview rasterfile viewer
  4. Message-ID: <536@sunpix.East.Sun.COM>
  5. Date: 4 Mar 91 17:19:38 GMT
  6.  
  7.  
  8. Vue is a Sunview tool to display images in a scrollable Sunview window.  
  9. Vue can be used with or without a filter.  Without a filter vue can be 
  10. used to display ordinary rasterfiles. With a user supplied filter, vue 
  11. can display whatever filetype the supplied filter works with.
  12.  
  13. Enclosed in the following shar, is the filter 'gif2ras'. 'Vue' used 
  14. with the filter 'gif2ras' makes a handy Sunview GIF viewer.  Using
  15. 'zcat' as s filter, 'Vue' can display compressed rasterfiles, with 
  16. pre-decompression.
  17.  
  18. ---- Cut Here and unpack ----
  19. #!/bin/sh
  20. # shar:    Shell Archiver  (v1.25)
  21. #    Packed Mon Mar  4 11:49:47 EST 1991 by taac-box!matthew
  22. #    from directory /home/matthew/.bin/src/Sunview/Vue
  23. #
  24. #    Run the following text with /bin/sh to create:
  25. #      Makefile
  26. #      hglass.cursor
  27. #      vue.c
  28. #      vue.h
  29. #      vue.icon
  30. #      vue.man
  31. #      gif2ras.c
  32. #      gif2ras.man
  33. #
  34. if test -f Makefile; then echo "File Makefile exists"; else
  35. echo "x - extracting Makefile (Text)"
  36. sed 's/^X//' << 'SHAR_EOF' > Makefile &&
  37. XEXEC    = vue gif2ras
  38. XCFLAGS    = -O
  39. XLDFLAGS    = -s
  40. XLDLIBS    = -lsuntool -lsunwindow -lpixrect
  41. X
  42. Xexec: $(EXEC)
  43. X
  44. Xlint:
  45. X    $(LINT) $(EXEC:=.c) $(LDLIBS) 
  46. X
  47. Xclean:
  48. X    $(RM) a.out core *.o
  49. X
  50. Xrealclean: clean
  51. X    $(RM) $(EXEC)
  52. X
  53. SHAR_EOF
  54. chmod 0777 Makefile || echo "restore of Makefile fails"
  55. fi
  56. if test -f hglass.cursor; then echo "File hglass.cursor exists"; else
  57. echo "x - extracting hglass.cursor (Text)"
  58. sed 's/^X//' << 'SHAR_EOF' > hglass.cursor &&
  59. X/* Format_version=1, Width=16, Height=16, Depth=1, Valid_bits_per_item=16
  60. X */
  61. X    0x7FFE,0x4002,0x200C,0x1A38,0x0FF0,0x07E0,0x03C0,0x0180,
  62. X    0x0180,0x0240,0x0520,0x0810,0x1108,0x23C4,0x47E2,0x7FFE
  63. SHAR_EOF
  64. chmod 0644 hglass.cursor || echo "restore of hglass.cursor fails"
  65. fi
  66. if test -f vue.c; then echo "File vue.c exists"; else
  67. echo "x - extracting vue.c (Text)"
  68. sed 's/^X//' << 'SHAR_EOF' > vue.c &&
  69. X/* 
  70. Xstatic char rcsID[] = "$Header: cshow.c,v 1.4 87/08/14 13:16:08 david Exp $"; 
  71. X */
  72. X
  73. X/* Define general items */
  74. X#define PROGRAMNAME     "vue"
  75. X#define ICON            "vue.icon"
  76. X#define CURSOR          "hglass.cursor"
  77. X#define DEFAULT_LABEL   "(hit right mouse button for menu)"
  78. X
  79. X/* Get #include */
  80. X#include <stdio.h>
  81. X#include <malloc.h>
  82. X#include <strings.h>
  83. X#include <sys/param.h>
  84. X#include <suntool/sunview.h>
  85. X#include <suntool/canvas.h>
  86. X#include <suntool/panel.h>
  87. X#include <suntool/scrollbar.h>
  88. X#include <suntool/expand_name.h>
  89. X#include <sunwindow/cms_mono.h>
  90. X#include "vue.h"
  91. X
  92. X/* Load the icon */
  93. Xstatic short icon_image[] = {
  94. X#include ICON
  95. X};
  96. Xmpr_static(icon_pixrect, 64, 64, 1, icon_image);
  97. X
  98. X/* Load the hour_glass cursor */
  99. Xstatic short cursor_image[] = {
  100. X#include CURSOR
  101. X};
  102. Xmpr_static(cursor_pixrect, 16, 16, 1, cursor_image);
  103. X
  104. X/* Define functions */
  105. Xint main();
  106. Xvoid frame_event();
  107. Xint show();
  108. Xvoid canvas_repaint(); 
  109. Xvoid update_canvas_menu();
  110. Xvoid set_frame_label();
  111. Xchar *basename();
  112. Xvoid create_control_panel();
  113. Xvoid control_panel_proc();
  114. Xvoid control_panel_done();
  115. Xvoid selection_update();
  116. Xvoid filter_update();
  117. XPixrect *load_pixrect();
  118. XPixrect *convert8to1();
  119. XPixrect *convert32to1();
  120. XPixrect *convert32to8();
  121. XPixrect *convert8to32();
  122. Xvoid init_colormap32();
  123. X
  124. X/* Define variables */
  125. Xstatic Icon icon;
  126. Xstatic Cursor hglass_cursor;
  127. Xstatic Frame frame;
  128. Xstatic Frame control_frame;
  129. Xstatic Canvas canvas;
  130. Xstatic Pixwin *pw;
  131. Xstatic Pixrect *pr  = 0;
  132. Xstatic Menu canvas_menu = 0;
  133. Xstatic Panel control_panel;
  134. Xstatic Panel_item fname_item;
  135. Xstatic Panel_item filter_item;
  136. Xstatic Panel_item order_item;
  137. Xstatic int where = 0;
  138. Xstatic int skip  = 0;
  139. Xstatic int nitems;
  140. Xstatic int max_depth;
  141. Xstatic char directory[MAXPATHLEN];
  142. Xstatic char *programname = PROGRAMNAME;
  143. Xstatic char *filter = "";
  144. Xstatic char current_image[MAXPATHLEN + 256];
  145. Xstatic char **filename = 0;
  146. Xstruct namelist *name_list;
  147. X
  148. X/* Define constants */
  149. X#define ERROR_PAUSE  2
  150. X#define ESCAPE_KEY   '\033'
  151. X
  152. Xint
  153. Xmain(argc, argv)
  154. Xint argc;
  155. Xchar *argv[];
  156. X{
  157. X    int getpid();
  158. X    char *getwd();
  159. X    char *sprintf();
  160. X
  161. X    /* Set 'programname' */
  162. X    if ( argc && *basename(argv[0]) != '\0')
  163. X        programname = basename(argv[0]);
  164. X
  165. X    /* Search command line for options */
  166. X    while (argc > 1 && argv[1][0] == '-') {    
  167. X        switch (argv[1][1]) {
  168. X            case 'f': /* If filter specified, get filter name */
  169. X                if ( argv[1][2] )  {
  170. X                    filter = &argv[1][2];
  171. X                } else {
  172. X                    if ( argc > 2 ) {
  173. X                        filter = argv[2];
  174. X                        argc--;
  175. X                        argv++;
  176. X                    }
  177. X                }
  178. X                    break;
  179. X            default: /* invalid option, complain */
  180. X                (void) fprintf(stderr, 
  181. X                    "Usage: %s [-f filter] [file]....\n", 
  182. X                    programname);
  183. X                return(1);
  184. X        }
  185. X        argc--;
  186. X        argv++;
  187. X    }
  188. X
  189. X    /* Set default fname_item for control panel */
  190. X    if (argc > 1 && basename(argv[1]) != argv[1]) {
  191. X        (void) strcpy(directory, argv[1]);
  192. X        (void) strcpy(basename(directory), "*");
  193. X    } else {
  194. X        (void) getwd(directory);
  195. X        (void) strcat(directory, "/*");
  196. X    }
  197. X        
  198. X    /* Create the icon  */
  199. X    icon = icon_create(ICON_IMAGE, &icon_pixrect,
  200. X        ICON_LABEL,  0,
  201. X        ICON_WIDTH,  icon_pixrect.pr_size.x,
  202. X        ICON_HEIGHT, icon_pixrect.pr_size.y,
  203. X        0);
  204. X
  205. X    /* Create the hourglass cursor */
  206. X    hglass_cursor = cursor_create(CURSOR_IMAGE, &cursor_pixrect, 0);
  207. X
  208. X    /* Create the frame */
  209. X    frame = window_create((Window) 0, FRAME,
  210. X        FRAME_ARGC_PTR_ARGV,     &argc, argv,
  211. X        FRAME_ICON,              icon,
  212. X        FRAME_PROPS_ACTIVE,      TRUE,
  213. X        FRAME_PROPS_ACTION_PROC, control_panel_proc,
  214. X        WIN_ERROR_MSG,            "Couldn't create frame",
  215. X        0);
  216. X
  217. X    /* Exit program if unable to create frame */
  218. X    if (frame == 0) 
  219. X        return(1);
  220. X
  221. X    /* Set frame label to default label */
  222. X    (void) strcpy(current_image, DEFAULT_LABEL);
  223. X    set_frame_label("%s: %s", current_image);
  224. X
  225. X    /* Create the canvas */
  226. X    canvas = window_create(frame, CANVAS,
  227. X        CANVAS_AUTO_EXPAND,       FALSE,
  228. X        CANVAS_AUTO_SHRINK,       FALSE,
  229. X        CANVAS_AUTO_CLEAR,        FALSE,
  230. X        CANVAS_RETAINED,          FALSE,
  231. X        CANVAS_REPAINT_PROC,      canvas_repaint,
  232. X        WIN_EVENT_PROC,           frame_event,
  233. X        WIN_CONSUME_KBD_EVENT,    WIN_ASCII_EVENTS,
  234. X        WIN_ERROR_MSG,            "Couldn't create canvas",
  235. X        WIN_HORIZONTAL_SCROLLBAR, scrollbar_create(SCROLL_LINE_HEIGHT, 1, 0),
  236. X        WIN_VERTICAL_SCROLLBAR,   scrollbar_create(SCROLL_LINE_HEIGHT, 1, 0),
  237. X        0);
  238. X
  239. X    /* Exit program if unable to create canvas */
  240. X    if (canvas == 0)
  241. X        return(1);
  242. X
  243. X    /* Get the pixwin for the canvas */
  244. X    pw = canvas_pixwin(canvas);
  245. X
  246. X    /* determine max depth of the pixwin */
  247. X    max_depth = pw->pw_pixrect->pr_depth;
  248. X
  249. X#ifdef CANVAS_COLOR24 /* If CANVAS_COLOR24 not declared, its not supported */
  250. X    /* Set 24-bit color mode if the frame buffer is deep enough */
  251. X    if (max_depth == 24 || max_depth == 32)
  252. X        window_set(canvas, CANVAS_COLOR24, TRUE, 0);
  253. X#endif /* CANVAS_COLOR24 */
  254. X
  255. X    /* Create a control panel */
  256. X    create_control_panel();
  257. X
  258. X    /* Create a selection menu from the remaining items */
  259. X    update_canvas_menu(--argc, ++argv);
  260. X
  261. X    /* Start main program loop */
  262. X    (void) window_main_loop(frame);
  263. X
  264. X    /* Exit program successfully */
  265. X    return(0);
  266. X}
  267. X
  268. Xvoid
  269. Xframe_event(window, event, arg)
  270. X    Window window;
  271. X    Event *event;
  272. X    caddr_t arg;
  273. X{
  274. X    int item;
  275. X
  276. X    /* If a mouse button is pressed inside the canvas, do its action */
  277. X    if (event_is_button(event) && event_is_down(event)) {
  278. X        switch(event_action(event)) {
  279. X            case MS_LEFT:   /* Goto previous image */
  280. X                skip  = (skip > 0 ? -1 : skip - 1);
  281. X                item  = (where ? where + skip : 1 + skip);
  282. X                item += (item <      1 ? nitems : 0);
  283. X                break;
  284. X            case MS_MIDDLE: /* Goto next image */
  285. X                skip  = (skip < 0 ?  1 : skip + 1);
  286. X                item  = where + skip;
  287. X                item -= (item > nitems ? nitems : 0);
  288. X                break;
  289. X            case MS_RIGHT:  /* Got to selected image */
  290. X                item = (int) menu_show(canvas_menu, canvas,
  291. X                    canvas_window_event(canvas, event), 0);
  292. X                skip = 0;
  293. X                break;
  294. X            default:
  295. X                break;
  296. X        }
  297. X
  298. X        /* If it is a valid 'item', load the file */
  299. X        if (item > 0 && item <= nitems && item != where ) {
  300. X            /* Announce you are loading a new image */
  301. X            set_frame_label("%s: %s (Loading)", filename[item - 1]);
  302. X            /* Show new file */
  303. X            if (show(filename[item - 1])) {
  304. X                /* Set "where" pointer to image being shown */
  305. X                where = item;
  306. X                /* Zero out the skip_image counter */
  307. X                skip = 0;
  308. X                /* Syncronize MS_RIGHT menu to image being shown */
  309. X                (void) menu_set(canvas_menu, MENU_SELECTED, item, 0);
  310. X                /* Create new title bar */
  311. X                (void) sprintf(current_image, "%s (%d x %d x %d)", 
  312. X                    filename[item - 1],
  313. X                    pr->pr_size.x, pr->pr_size.y, pr->pr_depth);
  314. X            } else {
  315. X                /* Report problem loading image */
  316. X                set_frame_label("%s: Error loading '%s'", filename[item - 1]);
  317. X                /* Pause so people can read it */
  318. X                sleep(ERROR_PAUSE);
  319. X            }
  320. X            /* Update the frame label */
  321. X            set_frame_label("%s: %s", current_image);
  322. X        }
  323. X    } else {
  324. X        /* if the escape key is pressed, open the control panel */
  325. X        if (event_action(event) == ESCAPE_KEY)
  326. X            control_panel_proc();
  327. X        /* handle all other canvas events */
  328. X        (void) window_default_event_proc(window, event, arg); 
  329. X    }
  330. X}
  331. X
  332. Xint
  333. Xshow(name)
  334. X    char *name;
  335. X{
  336. X    /* Define functions */
  337. X    char *sprintf();
  338. X
  339. X    /* Define local variables */
  340. X    Cursor current_cursor;
  341. X    char cmsname[CMS_NAMESIZE];
  342. X    colormap_t cm;
  343. X    Pixrect *new_pr = 0;
  344. X
  345. X    /* Get the current cursor */
  346. X    current_cursor = (Cursor) window_get(canvas,WIN_CURSOR);
  347. X
  348. X    /* Change cursor to hour glass */
  349. X    (void) window_set(canvas,WIN_CURSOR,hglass_cursor,0);
  350. X
  351. X    /* Load image into pixrect */
  352. X    new_pr = load_pixrect(name, &cm);
  353. X
  354. X    /* If an error in reading the file, return cursor to normal and return */
  355. X    if (!new_pr) {
  356. X        (void) window_set(canvas, WIN_CURSOR, current_cursor, 0);
  357. X        return (0);
  358. X    }
  359. X
  360. X    /* Check pixrect depth against canvas depth, process where necessary */
  361. X    switch (max_depth) {
  362. X        case  1:
  363. X            switch (new_pr->pr_depth) {
  364. X                case  1:
  365. X                    break;
  366. X                case  8:
  367. X                    new_pr = convert8to1(new_pr, &cm);
  368. X                    break;
  369. X                case 32:
  370. X                    new_pr = convert32to1(new_pr, &cm);
  371. X                    break;
  372. X                default:
  373. X                    pr_destroy(new_pr);
  374. X                    new_pr = (Pixrect *) 0;
  375. X                    break;
  376. X            }
  377. X            break;
  378. X        case  8:
  379. X            switch (new_pr->pr_depth) {
  380. X                case  1:
  381. X                    break;
  382. X                case  8:
  383. X                    break;
  384. X                case 32:
  385. X                    new_pr = convert32to8(new_pr, &cm);
  386. X                    break;
  387. X                default:
  388. X                    pr_destroy(new_pr);
  389. X                    new_pr = (Pixrect *) 0;
  390. X                    break;
  391. X            }
  392. X            break;
  393. X        case 24:
  394. X            switch (new_pr->pr_depth) {
  395. X                case  1:
  396. X                    pr_destroy(new_pr);
  397. X                    new_pr = (Pixrect *) 0;
  398. X                    break;
  399. X                case  8:
  400. X                    pr_destroy(new_pr);
  401. X                    new_pr = (Pixrect *) 0;
  402. X                    break;
  403. X                case 32:
  404. X                    pr_destroy(new_pr);
  405. X                    new_pr = (Pixrect *) 0;
  406. X                    break;
  407. X                default:
  408. X                    pr_destroy(new_pr);
  409. X                    new_pr = (Pixrect *) 0;
  410. X                    break;
  411. X            }
  412. X            break;
  413. X        case 32:
  414. X            switch (new_pr->pr_depth) {
  415. X                case  1:
  416. X                    break;
  417. X                case  8:
  418. X                    new_pr = convert8to32(new_pr, &cm);
  419. X                    break;
  420. X                case 32:
  421. X                    break;
  422. X                default:
  423. X                    pr_destroy(new_pr);
  424. X                    new_pr = (Pixrect *) 0;
  425. X                    break;
  426. X            }
  427. X            break;
  428. X        default:
  429. X            pr_destroy(new_pr);
  430. X            new_pr = (Pixrect *) 0;
  431. X            break;
  432. X    }
  433. X
  434. X    /* If an error in converting the file, return cursor to normal and return */
  435. X    if (!new_pr) {
  436. X        (void) window_set(canvas, WIN_CURSOR, current_cursor, 0);
  437. X        return (0);
  438. X    }
  439. X
  440. X    /* Set colormaps */
  441. X    switch (new_pr->pr_depth) {
  442. X        case 1:
  443. X            (void) pw_setcmsname(pw, CMS_MONOCHROME); 
  444. X            break;
  445. X        case 8:
  446. X            switch (cm.type) {
  447. X                case RMT_EQUAL_RGB:
  448. X                    (void) sprintf(cmsname, "rs-%05d-%03d", 
  449. X                        getpid(), cm.length);
  450. X                    (void) pw_setcmsname(pw, cmsname); 
  451. X                    (void) pw_putcolormap(pw, 0, cm.length,
  452. X                        cm.map[0], cm.map[1], cm.map[2]);
  453. X                    break;
  454. X                default:
  455. X                    break;
  456. X            }
  457. X        case 32:
  458. X            break;
  459. X        default:
  460. X            break;
  461. X    }
  462. X
  463. X    /* Blank the canvas */
  464. X    (void) pw_writebackground(pw, 0, 0, 
  465. X        pw->pw_pixrect->pr_size.x, pw->pw_pixrect->pr_size.y, PIX_SRC);
  466. X
  467. X    /* Resize the new canvas */
  468. X    (void) window_set(canvas, 
  469. X        CANVAS_WIDTH,  new_pr->pr_size.x, 
  470. X        CANVAS_HEIGHT, new_pr->pr_size.y, 
  471. X        0);
  472. X    
  473. X    /* Write the image to the canvas */
  474. X    (void) pw_write(pw, 0, 0, 
  475. X        new_pr->pr_size.x, new_pr->pr_size.y, PIX_SRC, new_pr, 0, 0);
  476. X
  477. X    /* All finished. Clean up and return success */
  478. X    if (pr)
  479. X        pr_destroy(pr);
  480. X    pr = new_pr;
  481. X    (void) window_set(canvas, WIN_CURSOR, current_cursor, 0);
  482. X    return(1);
  483. X}
  484. X
  485. X/*ARGSUSED*/
  486. Xvoid
  487. Xcanvas_repaint(canvas, pw, area)
  488. XCanvas canvas;
  489. XPixwin *pw;
  490. XRectlist *area;
  491. X{
  492. X    if (pr) {
  493. X        /* Repaint the image */
  494. X        (void) pw_write(pw, 0, 0, 
  495. X            pr->pr_size.x, pr->pr_size.y, PIX_SRC, pr, 0, 0);
  496. X    } else {
  497. X        /* Blank the canvas */
  498. X        (void) pw_writebackground(pw, 0, 0, 
  499. X            pw->pw_pixrect->pr_size.x, pw->pw_pixrect->pr_size.y, PIX_SRC);
  500. X    }
  501. X}
  502. X
  503. Xvoid
  504. Xupdate_canvas_menu(argc, argv)
  505. Xint argc;
  506. Xchar **argv;
  507. X{
  508. X    int index;
  509. X
  510. X    /* Destroy the old menu */    
  511. X    if (canvas_menu != 0)
  512. X        menu_destroy(canvas_menu);
  513. X    
  514. X    /* Create a new one     */
  515. X    canvas_menu = menu_create(0);
  516. X
  517. X    /* and fill it in       */
  518. X    for (index = 0; index < argc; index++)
  519. X        (void) menu_set(canvas_menu, MENU_STRING_ITEM, 
  520. X            argv[index], index + 1, 0);
  521. X
  522. X    /* and set some variables for frame_event() */
  523. X    skip =0;
  524. X    where = 0;
  525. X    nitems = argc;
  526. X    filename = argv;
  527. X}
  528. X
  529. Xvoid
  530. Xset_frame_label(format, filename)
  531. Xchar *format;
  532. Xchar *filename;
  533. X{
  534. X    char *sprintf();
  535. X    char *title[MAXPATHLEN];
  536. X
  537. X    /* create the label */
  538. X    (void) sprintf(title, format, programname, filename);
  539. X    /* send it to the frame */
  540. X    (void) window_set(frame, FRAME_LABEL, title, 0);
  541. X}
  542. X
  543. Xchar *
  544. Xbasename(pn)
  545. Xchar *pn;      /* pointer to pathname */
  546. X{
  547. X    char *sp;  /* search pointer */
  548. X    
  549. X    /* set search pointer to the start of pathname */
  550. X    sp = pn;
  551. X
  552. X    /* search pathname for last delimeter */
  553. X    while ( *sp != '\0' ) {
  554. X        if ( *sp++ == '/' )
  555. X            pn = sp; 
  556. X    }
  557. X
  558. X    /* return the basename */
  559. X    return(pn);
  560. X}
  561. X
  562. Xvoid
  563. Xcreate_control_panel()
  564. X{
  565. X
  566. X    control_frame = window_create(frame, FRAME, 
  567. X        FRAME_LABEL,      programname,
  568. X        FRAME_SHOW_LABEL, TRUE,
  569. X        WIN_SHOW,         FALSE, 
  570. X        0);
  571. X
  572. X    control_panel = window_create(control_frame, PANEL, 0); 
  573. X
  574. X    fname_item = panel_create_item(control_panel, PANEL_TEXT,
  575. X        PANEL_LABEL_Y,              ATTR_ROW(0),
  576. X        PANEL_LABEL_X,              ATTR_COL(0),
  577. X        PANEL_VALUE_DISPLAY_LENGTH, 32,
  578. X        PANEL_LABEL_STRING,         "File:  ",
  579. X        PANEL_VALUE,                directory,
  580. X        0);
  581. X
  582. X    (void) panel_create_item(control_panel, PANEL_BUTTON,
  583. X        PANEL_LABEL_X,              ATTR_COL(42),
  584. X        PANEL_LABEL_IMAGE, panel_button_image(control_panel, 
  585. X            "Update Menu", 15, (Pixfont *) 0),
  586. X        PANEL_NOTIFY_PROC, selection_update,
  587. X        0);
  588. X
  589. X    filter_item = panel_create_item(control_panel, PANEL_TEXT,
  590. X        PANEL_LABEL_Y,              ATTR_ROW(1),
  591. X        PANEL_LABEL_X,              ATTR_COL(0),
  592. X        PANEL_VALUE_DISPLAY_LENGTH, 32,
  593. X        PANEL_LABEL_STRING,         "Filter:",
  594. X        PANEL_VALUE,                filter,
  595. X        0);
  596. X
  597. X    (void) panel_create_item(control_panel, PANEL_BUTTON,
  598. X        PANEL_LABEL_X,              ATTR_COL(42),
  599. X        PANEL_LABEL_IMAGE,          panel_button_image(control_panel, 
  600. X                                        "Update filter", 15, (Pixfont *) 0),
  601. X        PANEL_NOTIFY_PROC,          filter_update,
  602. X        0);
  603. X
  604. X    order_item = panel_create_item(control_panel, PANEL_CYCLE,
  605. X        PANEL_LABEL_Y,              ATTR_ROW(2),
  606. X        PANEL_LABEL_X,              ATTR_COL(0),
  607. X        PANEL_LABEL_STRING,         "Color ordering:",
  608. X        PANEL_CHOICE_STRINGS,       "rgb", "bgr", 0,
  609. X        0);
  610. X
  611. X    (void) panel_create_item(control_panel, PANEL_BUTTON,
  612. X        PANEL_LABEL_X,              ATTR_COL(42),
  613. X        PANEL_LABEL_IMAGE,          panel_button_image(control_panel, 
  614. X                                       "Done", 15, (Pixfont *) 0),
  615. X        PANEL_NOTIFY_PROC,          control_panel_done,
  616. X        0);
  617. X
  618. X    (void) window_set(control_panel, PANEL_CARET_ITEM, fname_item, 0);
  619. X
  620. X    (void) window_fit(control_panel);
  621. X    (void) window_fit(control_frame);
  622. X
  623. X}
  624. X
  625. Xvoid
  626. Xcontrol_panel_proc()
  627. X{
  628. X    window_set(control_frame, 
  629. X        WIN_X,    50, 
  630. X        WIN_Y,    50, 
  631. X        WIN_SHOW, TRUE,
  632. X        0);
  633. X}
  634. X
  635. Xvoid
  636. Xcontrol_panel_done()
  637. X{
  638. X    window_set(control_frame, WIN_SHOW, FALSE, 0);
  639. X}
  640. X
  641. Xvoid
  642. Xselection_update()
  643. X{
  644. X    static char previous_dir[MAXPATHLEN];
  645. X    char current_dir[MAXPATHLEN];
  646. X    char fname[MAXPATHLEN];
  647. X
  648. X    /* Get a copy of fname_item */
  649. X    (void) strcpy(current_dir, panel_get_value(fname_item));
  650. X    (void) strcpy(fname, current_dir);
  651. X
  652. X    /* Truncate current_dir to the directory component */
  653. X    (void) strcpy(basename(current_dir), "");
  654. X
  655. X    /* Truncate fname to filename only */
  656. X    /* If no filename specified, assume wildcard of '*' */
  657. X    if (!strlen(basename(fname))) {
  658. X        (void) strcat(fname, "*");
  659. X        (void) panel_set_value(fname_item, (caddr_t) fname); 
  660. X    }
  661. X
  662. X    /* Change directories to match fname_item */
  663. X    if (strcmp(previous_dir, current_dir)) {
  664. X        (void) chdir(current_dir);
  665. X        (void) strcpy(previous_dir, current_dir);
  666. X    }
  667. X
  668. X    /* Convert filename to list of files */
  669. X    name_list = expand_name(basename(fname));
  670. X
  671. X    /* Convert the expanded filename to a canvas menu */
  672. X    update_canvas_menu((int) name_list->count, name_list->names);
  673. X}
  674. X
  675. Xvoid
  676. Xfilter_update()
  677. X{
  678. X    /* Get the filter_item value from the control panel */
  679. X    filter = (char *) panel_get_value(filter_item);
  680. X
  681. X    /* Skip leading whitespace */
  682. X    while ( *filter == ' ' || *filter == '\t' ) 
  683. X        filter++; 
  684. X}
  685. X
  686. XPixrect *
  687. Xload_pixrect(name, cm)
  688. Xchar *name;
  689. Xcolormap_t *cm;
  690. X{
  691. X    FILE *inf;
  692. X    Pixrect *tpr;
  693. X    char *cmd;
  694. X    char *cmdfmt = "(%s) < %s";
  695. X
  696. X    /* Load image into pixrect */
  697. X    if (*filter) {
  698. X        /* Allocate enough space to create commandline */
  699. X        cmd = (char *) malloc((unsigned) 
  700. X            (strlen(cmdfmt) + strlen(filter) + strlen(name)));
  701. X        /* Verify allocation of commandline space */
  702. X        if (cmd) {
  703. X            /* Load image by piping the file thru a filter */
  704. X            (void) sprintf(cmd, cmdfmt, filter, name);
  705. X            if (!(inf = popen(cmd, "r")))
  706. X                return((Pixrect *) 0);
  707. X            tpr = pr_load(inf, cm);
  708. X            if (pclose(inf))
  709. X                tpr = (Pixrect *) 0;
  710. X            (void) free(cmd);
  711. X        } else {
  712. X            (void) fprintf(stderr, 
  713. X                "Error allocating space for filter commandline");
  714. X        }
  715. X    } else {
  716. X        if (!(inf = fopen(name, "r")))
  717. X            return((Pixrect *) 0);
  718. X        tpr = pr_load(inf, cm);
  719. X        if (fclose(inf))
  720. X            tpr = (Pixrect *) 0;
  721. X    }
  722. X
  723. X    /* And return */
  724. X    return(tpr);
  725. X}
  726. X
  727. XPixrect *
  728. Xconvert8to1(pr8, cm)
  729. XPixrect *pr8;
  730. Xcolormap_t *cm;
  731. X{
  732. X    /* Define function variables */
  733. X    Pixrect *pr1;
  734. X    unsigned char *cm1 = 0;
  735. X    int x, y, pixel8, pixel1;
  736. X    unsigned long avg = 0;
  737. X
  738. X    /* Create an 1-bit pixrect */
  739. X    pr1 = mem_create(pr8->pr_size.x, pr8->pr_size.y, 1);
  740. X
  741. X    /* Verify creation of mem_rect */
  742. X    if (!pr1) {
  743. X        pr_destroy(pr8);
  744. X        return((Pixrect *) 0);
  745. X    }
  746. X
  747. X    /* Convert the 8-bit pixrect to an 1-bit pixrect */
  748. X    for (y = 0; y < pr8->pr_size.y; y++) {
  749. X        for (x = 0; x < pr8->pr_size.x; x++) {
  750. X            pixel8 = pr_get(pr8, x, y);
  751. X            pixel1 = (ntscr[cm->map[0][pixel8]] + 
  752. X                      ntscg[cm->map[1][pixel8]] + 
  753. X                      ntscb[cm->map[2][pixel8]])/256;
  754. X            pixel1 = pixel1 <= dither_table[y%16][x%16];
  755. X            pr_put(pr1, x, y, pixel1);
  756. X        }
  757. X    }
  758. X
  759. X    /* Destroy the old pixrect, and return the new */
  760. X    pr_destroy(pr8);
  761. X    return(pr1);
  762. X}
  763. X
  764. XPixrect *
  765. Xconvert32to1(pr32, cm)
  766. XPixrect *pr32;
  767. Xcolormap_t *cm;
  768. X{
  769. X    /* Define function variables */
  770. X    Pixrect *pr1;
  771. X    unsigned char *cm1 = 0;
  772. X    int x, y, blu_shift, grn_shift, red_shift, pixel32, pixel1;
  773. X
  774. X    /* Create an 1-bit pixrect */
  775. X    pr1 = mem_create(pr32->pr_size.x, pr32->pr_size.y, 1);
  776. X
  777. X    /* Verify creation of mem_rect */
  778. X    if (!pr1) {
  779. X        pr_destroy(pr32);
  780. X        return((Pixrect *) 0);
  781. X    }
  782. X
  783. X    /* Set pixel shift value in accordance with the panel selection */
  784. X    switch ((int) panel_get_value(order_item)) {
  785. X        case 0: /* rgb */
  786. X            blu_shift =  0;
  787. X            grn_shift =  8;
  788. X            red_shift = 16;
  789. X            break;
  790. X        case 1: /* bgr */
  791. X            blu_shift = 16;
  792. X            grn_shift =  8;
  793. X            red_shift =  0;
  794. X            break;
  795. X        default: /* rgb */
  796. X            blu_shift =  0;
  797. X            grn_shift =  8;
  798. X            red_shift = 16;
  799. X            break;
  800. X    }
  801. X
  802. X    /* Convert the 32-bit pixrect to an 1-bit pixrect */
  803. X    for (y = 0; y < pr32->pr_size.y; y++) {
  804. X        for (x = 0; x < pr32->pr_size.x; x++) {
  805. X            pixel32 = pr_get(pr32, x, y);
  806. X            pixel1 = (ntscb[((pixel32 >> blu_shift) & 0xff)] + 
  807. X                      ntscg[((pixel32 >> grn_shift) & 0xff)] + 
  808. X                      ntscr[((pixel32 >> red_shift) & 0xff)])/256;
  809. X            pixel1 = pixel1 <= dither_table[y%16][x%16];
  810. X            pr_put(pr1, x, y, pixel1);
  811. X        }
  812. X    }
  813. X
  814. X    /* Destroy the old pixrect, and return the new */
  815. X    pr_destroy(pr32);
  816. X    return(pr1);
  817. X}
  818. X
  819. XPixrect *
  820. Xconvert32to8(pr32, cm)
  821. XPixrect *pr32;
  822. Xcolormap_t *cm;
  823. X{
  824. X
  825. X#undef  CM_SIZE
  826. X#define CM_SIZE 256
  827. X#define MAX_BLU   4
  828. X#define BLU_STEP 85    
  829. X#define MAX_GRN   8
  830. X#define GRN_STEP 36    
  831. X#define MAX_RED   8
  832. X#define RED_STEP 36    
  833. X
  834. X    /* Define function variables */
  835. X    int blu_index, grn_index, red_index, cm_index = 0;
  836. X    Pixrect *pr8 = 0;
  837. X    unsigned char *cm8 = 0;
  838. X    int x, y, pixel32, pixel8;
  839. X    int order, blu_shift, grn_shift, red_shift;
  840. X
  841. X    /* Get the space for a colormap */
  842. X    cm8 = (unsigned char *) malloc(CM_SIZE * 3);
  843. X
  844. X    /* Verify allocation of colormap space */
  845. X    if (!cm) {
  846. X        pr_destroy(pr32);
  847. X        return((Pixrect *) 0);
  848. X    }
  849. X
  850. X    /* Create a colormap table */
  851. X    cm->type = RMT_EQUAL_RGB;
  852. X    cm->length = CM_SIZE;
  853. X    cm->map[0] = cm8;
  854. X    cm->map[1] = cm->map[0] + CM_SIZE;
  855. X    cm->map[2] = cm->map[1] + CM_SIZE;
  856. X
  857. X    /* Fill-in the colormap */
  858. X    for (blu_index = 0; blu_index < MAX_BLU; blu_index++) {
  859. X        for (grn_index = 0; grn_index < MAX_GRN; grn_index++) {
  860. X            for (red_index = 0; red_index < MAX_RED; red_index++) {
  861. X                cm->map[0][cm_index] = red_index * RED_STEP;
  862. X                cm->map[1][cm_index] = grn_index * GRN_STEP;
  863. X                cm->map[2][cm_index] = blu_index * BLU_STEP;
  864. X                cm_index++;
  865. X            }
  866. X        }
  867. X    }
  868. X
  869. X    /* Create an 8-bit pixrect */
  870. X    pr8 = mem_create(pr32->pr_size.x, pr32->pr_size.y, 8);
  871. X
  872. X    /* Verify creation of mem_rect */
  873. X    if (!pr8) {
  874. X        pr_destroy(pr32);
  875. X        return((Pixrect *) 0);
  876. X    }
  877. X
  878. X    /* Set pixel shift value in accordance with the panel selection */
  879. X    switch ((int) panel_get_value(order_item)) {
  880. X        case 0: /* rgb */
  881. X            blu_shift =  0;
  882. X            grn_shift = 10;
  883. X            red_shift = 21;
  884. X            break;
  885. X        case 1: /* bgr */
  886. X            blu_shift = 16;
  887. X            grn_shift = 10;
  888. X            red_shift =  5;
  889. X            break;
  890. X        default: /* rgb */
  891. X            blu_shift =  0;
  892. X            grn_shift = 10;
  893. X            red_shift = 21;
  894. X            break;
  895. X    }
  896. X
  897. X    /* Convert the 32-bit pixrect to an 8-bit pixrect */
  898. X    for (y = 0; y < pr32->pr_size.y; y++) {
  899. X        for (x = 0; x < pr32->pr_size.x; x++) {
  900. X            pixel32 = pr_get(pr32, x, y);
  901. X            pixel8 = ((pixel32 >> blu_shift) & 0xc0) | 
  902. X                     ((pixel32 >> grn_shift) & 0x38) |
  903. X                     ((pixel32 >> red_shift) & 0x07);
  904. X            pr_put(pr8, x, y, pixel8);
  905. X        }
  906. X    }
  907. X    /* Destroy the old pixrect, and return the new */
  908. X    pr_destroy(pr32);
  909. X    return(pr8);
  910. X}
  911. X
  912. XPixrect *
  913. Xconvert8to32(pr8, cm)
  914. XPixrect *pr8;
  915. Xcolormap_t *cm;
  916. X{
  917. X    /* Define function variables */
  918. X    Pixrect *pr32 = 0;
  919. X    int x, y, pixel32, pixel8;
  920. X    int order, blu_shift, grn_shift, red_shift;
  921. X
  922. X    /* Create an 32-bit pixrect */
  923. X    pr32 = mem_create(pr8->pr_size.x, pr8->pr_size.y, 32);
  924. X
  925. X    /* Verify creation of mem_rect */
  926. X    if (!pr32) {
  927. X        pr_destroy(pr8);
  928. X        return((Pixrect *) 0);
  929. X    }
  930. X
  931. X    /* Set pixel shift value in accordance with the panel selection */
  932. X    switch ((int) panel_get_value(order_item)) {
  933. X        case 0: /* rgb */
  934. X            blu_shift =  0;
  935. X            grn_shift =  8;
  936. X            red_shift = 16;
  937. X            break;
  938. X        case 1: /* bgr */
  939. X            blu_shift = 16;
  940. X            grn_shift =  8;
  941. X            red_shift =  0;
  942. X            break;
  943. X        default: /* rgb */
  944. X            blu_shift =  0;
  945. X            grn_shift =  8;
  946. X            red_shift = 16;
  947. X            break;
  948. X    }
  949. X
  950. X    /* Convert the 8-bit pixrect to an 32-bit pixrect */
  951. X    for (y = 0; y < pr8->pr_size.y; y++) {
  952. X        for (x = 0; x < pr8->pr_size.x; x++) {
  953. X            pixel8  = pr_get(pr8, x, y);
  954. X            pixel32 = cm->map[2][pixel8] << blu_shift |
  955. X                      cm->map[1][pixel8] << grn_shift |
  956. X                      cm->map[0][pixel8] << red_shift;
  957. X            pr_put(pr32, x, y, pixel32);
  958. X        }
  959. X    }
  960. X    /* Destroy the old pixrect, and return the new */
  961. X    pr_destroy(pr8);
  962. X    return(pr32);
  963. X}
  964. X
  965. SHAR_EOF
  966. chmod 0777 vue.c || echo "restore of vue.c fails"
  967. fi
  968. if test -f vue.h; then echo "File vue.h exists"; else
  969. echo "x - extracting vue.h (Text)"
  970. sed 's/^X//' << 'SHAR_EOF' > vue.h &&
  971. Xstatic unsigned int ntscr[] = {
  972. X        0,   77,  153,  230,  306,  383,  459,  536,
  973. X      612,  689,  765,  842,  919,  995, 1072, 1148,
  974. X     1225, 1301, 1378, 1454, 1531, 1607, 1684, 1761,
  975. X     1837, 1914, 1990, 2067, 2143, 2220, 2296, 2373,
  976. X     2449, 2526, 2602, 2679, 2756, 2832, 2909, 2985,
  977. X     3062, 3138, 3215, 3291, 3368, 3444, 3521, 3598,
  978. X     3674, 3751, 3827, 3904, 3980, 4057, 4133, 4210,
  979. X     4286, 4363, 4440, 4516, 4593, 4669, 4746, 4822,
  980. X     4899, 4975, 5052, 5128, 5205, 5282, 5358, 5435,
  981. X     5511, 5588, 5664, 5741, 5817, 5894, 5970, 6047,
  982. X     6124, 6200, 6277, 6353, 6430, 6506, 6583, 6659,
  983. X     6736, 6812, 6889, 6966, 7042, 7119, 7195, 7272,
  984. X     7348, 7425, 7501, 7578, 7654, 7731, 7807, 7884,
  985. X     7961, 8037, 8114, 8190, 8267, 8343, 8420, 8496,
  986. X     8573, 8649, 8726, 8803, 8879, 8956, 9032, 9109,
  987. X     9185, 9262, 9338, 9415, 9491, 9568, 9645, 9721,
  988. X     9798, 9874, 9951,10027,10104,10180,10257,10333,
  989. X    10410,10487,10563,10640,10716,10793,10869,10946,
  990. X    11022,11099,11175,11252,11329,11405,11482,11558,
  991. X    11635,11711,11788,11864,11941,12017,12094,12170,
  992. X    12247,12324,12400,12477,12553,12630,12706,12783,
  993. X    12859,12936,13012,13089,13166,13242,13319,13395,
  994. X    13472,13548,13625,13701,13778,13854,13931,14008,
  995. X    14084,14161,14237,14314,14390,14467,14543,14620,
  996. X    14696,14773,14850,14926,15003,15079,15156,15232,
  997. X    15309,15385,15462,15538,15615,15692,15768,15845,
  998. X    15921,15998,16074,16151,16227,16304,16380,16457,
  999. X    16534,16610,16687,16763,16840,16916,16993,17069,
  1000. X    17146,17222,17299,17375,17452,17529,17605,17682,
  1001. X    17758,17835,17911,17988,18064,18141,18217,18294,
  1002. X    18371,18447,18524,18600,18677,18753,18830,18906,
  1003. X    18983,19059,19136,19213,19289,19366,19442,19519};
  1004. X
  1005. Xstatic unsigned int ntscg[] = {
  1006. X        0,  150,  301,  451,  601,  751,  902, 1052,
  1007. X     1202, 1352, 1503, 1653, 1803, 1954, 2104, 2254,
  1008. X     2404, 2555, 2705, 2855, 3005, 3156, 3306, 3456,
  1009. X     3607, 3757, 3907, 4057, 4208, 4358, 4508, 4658,
  1010. X     4809, 4959, 5109, 5260, 5410, 5560, 5710, 5861,
  1011. X     6011, 6161, 6311, 6462, 6612, 6762, 6913, 7063,
  1012. X     7213, 7363, 7514, 7664, 7814, 7964, 8115, 8265,
  1013. X     8415, 8566, 8716, 8866, 9016, 9167, 9317, 9467,
  1014. X     9617, 9768, 9918,10068,10218,10369,10519,10669,
  1015. X    10820,10970,11120,11270,11421,11571,11721,11871,
  1016. X    12022,12172,12322,12473,12623,12773,12923,13074,
  1017. X    13224,13374,13524,13675,13825,13975,14126,14276,
  1018. X    14426,14576,14727,14877,15027,15177,15328,15478,
  1019. X    15628,15779,15929,16079,16229,16380,16530,16680,
  1020. X    16830,16981,17131,17281,17432,17582,17732,17882,
  1021. X    18033,18183,18333,18483,18634,18784,18934,19085,
  1022. X    19235,19385,19535,19686,19836,19986,20136,20287,
  1023. X    20437,20587,20738,20888,21038,21188,21339,21489,
  1024. X    21639,21789,21940,22090,22240,22391,22541,22691,
  1025. X    22841,22992,23142,23292,23442,23593,23743,23893,
  1026. X    24044,24194,24344,24494,24645,24795,24945,25095,
  1027. X    25246,25396,25546,25697,25847,25997,26147,26298,
  1028. X    26448,26598,26748,26899,27049,27199,27350,27500,
  1029. X    27650,27800,27951,28101,28251,28401,28552,28702,
  1030. X    28852,29002,29153,29303,29453,29604,29754,29904,
  1031. X    30054,30205,30355,30505,30655,30806,30956,31106,
  1032. X    31257,31407,31557,31707,31858,32008,32158,32308,
  1033. X    32459,32609,32759,32910,33060,33210,33360,33511,
  1034. X    33661,33811,33961,34112,34262,34412,34563,34713,
  1035. X    34863,35013,35164,35314,35464,35614,35765,35915,
  1036. X    36065,36216,36366,36516,36666,36817,36967,37117,
  1037. X    37267,37418,37568,37718,37869,38019,38169,38319};
  1038. X
  1039. Xstatic unsigned int ntscb[] = {
  1040. X        0,   29,   58,   88,  117,  146,  175,  204,
  1041. X      233,  263,  292,  321,  350,  379,  409,  438,
  1042. X      467,  496,  525,  554,  584,  613,  642,  671,
  1043. X      700,  730,  759,  788,  817,  846,  876,  905,
  1044. X      934,  963,  992, 1021, 1051, 1080, 1109, 1138,
  1045. X     1167, 1197, 1226, 1255, 1284, 1313, 1342, 1372,
  1046. X     1401, 1430, 1459, 1488, 1518, 1547, 1576, 1605,
  1047. X     1634, 1663, 1693, 1722, 1751, 1780, 1809, 1839,
  1048. X     1868, 1897, 1926, 1955, 1985, 2014, 2043, 2072,
  1049. X     2101, 2130, 2160, 2189, 2218, 2247, 2276, 2306,
  1050. X     2335, 2364, 2393, 2422, 2451, 2481, 2510, 2539,
  1051. X     2568, 2597, 2627, 2656, 2685, 2714, 2743, 2772,
  1052. X     2802, 2831, 2860, 2889, 2918, 2948, 2977, 3006,
  1053. X     3035, 3064, 3094, 3123, 3152, 3181, 3210, 3239,
  1054. X     3269, 3298, 3327, 3356, 3385, 3415, 3444, 3473,
  1055. X     3502, 3531, 3560, 3590, 3619, 3648, 3677, 3706,
  1056. X     3736, 3765, 3794, 3823, 3852, 3881, 3911, 3940,
  1057. X     3969, 3998, 4027, 4057, 4086, 4115, 4144, 4173,
  1058. X     4202, 4232, 4261, 4290, 4319, 4348, 4378, 4407,
  1059. X     4436, 4465, 4494, 4524, 4553, 4582, 4611, 4640,
  1060. X     4669, 4699, 4728, 4757, 4786, 4815, 4845, 4874,
  1061. X     4903, 4932, 4961, 4990, 5020, 5049, 5078, 5107,
  1062. X     5136, 5166, 5195, 5224, 5253, 5282, 5311, 5341,
  1063. X     5370, 5399, 5428, 5457, 5487, 5516, 5545, 5574,
  1064. X     5603, 5633, 5662, 5691, 5720, 5749, 5778, 5808,
  1065. X     5837, 5866, 5895, 5924, 5954, 5983, 6012, 6041,
  1066. X     6070, 6099, 6129, 6158, 6187, 6216, 6245, 6275,
  1067. X     6304, 6333, 6362, 6391, 6420, 6450, 6479, 6508,
  1068. X     6537, 6566, 6596, 6625, 6654, 6683, 6712, 6742,
  1069. X     6771, 6800, 6829, 6858, 6887, 6917, 6946, 6975,
  1070. X     7004, 7033, 7063, 7092, 7121, 7150, 7179, 7208,
  1071. X     7238, 7267, 7296, 7325, 7354, 7384, 7413, 7442};
  1072. X
  1073. Xstatic int dither_table[16][16] = {
  1074. X    {  0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,254},
  1075. X    {128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127},
  1076. X    { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223},
  1077. X    {160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95},
  1078. X    {  8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247},
  1079. X    {136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119},
  1080. X    { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215},
  1081. X    {168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87},
  1082. X    {  2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253},
  1083. X    {130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125},
  1084. X    { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221},
  1085. X    {162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93},
  1086. X    { 10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245},
  1087. X    {138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117},
  1088. X    { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213},
  1089. X    {170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85}};
  1090. X
  1091. SHAR_EOF
  1092. chmod 0644 vue.h || echo "restore of vue.h fails"
  1093. fi
  1094. if test -f vue.icon; then echo "File vue.icon exists"; else
  1095. echo "x - extracting vue.icon (Text)"
  1096. sed 's/^X//' << 'SHAR_EOF' > vue.icon &&
  1097. X/* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16
  1098. X */
  1099. X    0x3FFF,0xFFFF,0xFFFF,0xFFFC,0x7FFF,0xFFFF,0xFFFF,0xFFFE,
  1100. X    0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xE083,0x5555,0x5591,0x1107,
  1101. X    0xE092,0xAAAA,0xAA88,0x8927,0xE0BB,0x5555,0x55A2,0x2377,
  1102. X    0xE092,0xAAAA,0xAAC4,0x4527,0xE083,0x5555,0x5591,0x1107,
  1103. X    0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xE080,0x0000,0x0000,0x0007,
  1104. X    0xE480,0x0000,0x0000,0x0007,0xEE80,0x0000,0x0000,0x0007,
  1105. X    0xE480,0x0000,0x0000,0x0007,0xE080,0x0000,0x0000,0x0007,
  1106. X    0xFF80,0x0000,0x0000,0x0007,0xF580,0x0000,0x0000,0x0007,
  1107. X    0xEA80,0x0000,0x0000,0x0007,0xF59C,0x1C00,0x0000,0x0007,
  1108. X    0xEA8C,0x0800,0x0000,0x0007,0xF586,0x1000,0x0000,0x0007,
  1109. X    0xEA86,0x1000,0x0000,0x0007,0xF586,0x10F3,0xC1E0,0x0007,
  1110. X    0xEA83,0x2061,0x8618,0x0007,0xF583,0x2061,0x8C0C,0x0007,
  1111. X    0xEA83,0x2061,0x8C0C,0x0007,0xF581,0x8061,0x8FFC,0x0007,
  1112. X    0xEA81,0xC061,0x8C00,0x0007,0xF581,0xC061,0x8C00,0x0007,
  1113. X    0xEA80,0x8061,0x8600,0x0007,0xF580,0x8073,0x830C,0x0007,
  1114. X    0xEA80,0x803C,0xC1F0,0x0007,0xFF80,0x0000,0x0000,0x0007,
  1115. X    0xE880,0x0000,0x0000,0x0007,0xE280,0x0000,0x0000,0x0007,
  1116. X    0xE480,0x0000,0x0000,0x0007,0xF180,0x0000,0x0000,0x0007,
  1117. X    0xE880,0x0000,0x0000,0x0007,0xE280,0x0000,0x0000,0x0007,
  1118. X    0xE480,0x0000,0x0000,0x0007,0xF180,0x0000,0x0000,0x0007,
  1119. X    0xE880,0x0000,0x0000,0x0007,0xE280,0x0000,0x0000,0x0007,
  1120. X    0xE480,0x0000,0x0000,0x0007,0xF180,0x0000,0x0000,0x0007,
  1121. X    0xE880,0x0000,0x0000,0x0007,0xE280,0x0000,0x0000,0x0007,
  1122. X    0xE480,0x0000,0x0000,0x0007,0xF180,0x0000,0x0000,0x0007,
  1123. X    0xE880,0x0000,0x0000,0x0007,0xE280,0x0000,0x0000,0x0007,
  1124. X    0xE480,0x0000,0x0000,0x0007,0xF180,0x0000,0x0000,0x0007,
  1125. X    0xE880,0x0000,0x0000,0x0007,0xE280,0x0000,0x0000,0x0007,
  1126. X    0xE480,0x0000,0x0000,0x0007,0xFF80,0x0000,0x0000,0x0007,
  1127. X    0xE080,0x0000,0x0000,0x0007,0xE480,0x0000,0x0000,0x0007,
  1128. X    0xEE80,0x0000,0x0000,0x0007,0xE480,0x0000,0x0000,0x0007,
  1129. X    0xE080,0x0000,0x0000,0x0007,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
  1130. X    0x7FFF,0xFFFF,0xFFFF,0xFFFE,0x3FFF,0xFFFF,0xFFFF,0xFFFC
  1131. SHAR_EOF
  1132. chmod 0777 vue.icon || echo "restore of vue.icon fails"
  1133. fi
  1134. if test -f vue.man; then echo "File vue.man exists"; else
  1135. echo "x - extracting vue.man (Text)"
  1136. sed 's/^X//' << 'SHAR_EOF' > vue.man &&
  1137. X.TH VUE L
  1138. X.SH NAME
  1139. Xvue \- a Sunview rasterfile display program
  1140. X.SH SYNOPSIS
  1141. X\fBvue\fP [ \fB-f filter\fP ] [ \fBfilename... \fP]
  1142. X.SH DESCRIPTION
  1143. XVue is a Sunview tool to display images in a scrollable Sunview 
  1144. Xwindow. Vue can be used with or without a filter. Without a filter
  1145. Xvue can be used to display ordinary rasterfiles. With a user 
  1146. Xsupplied filter, vue can display whatever filetype the supplied 
  1147. Xfilter works with.
  1148. X
  1149. XFile selection within vue is very easy. 
  1150. XWhile the mouse cursor is inside the display area, 
  1151. Xa new file may selected using any of the three mouse buttons. 
  1152. XPressing the right mouse button will display a menu of available files.
  1153. XTo select a new file, simply high-lighting the desired file, 
  1154. Xand release the button.
  1155. XSingle stepping thru the file menu is accomplished by clicking 
  1156. Xthe left and middle mouse buttons. 
  1157. XClicking the left mouse button to go up the list. 
  1158. XClicking the middle mouse button to go down the list. 
  1159. XVue will "roll-over" upon reaching either end of the list. 
  1160. XVue will also "step over" files it cannot load 
  1161. X(simply press the same mouse button again).
  1162. X
  1163. XVue uses the frame's label bar to display program status messages,
  1164. Xand the name of the file being displayed.
  1165. X
  1166. XAccess to vue's control panel can be obtain by selecting [props] from
  1167. Xvue's frame menu, or by pressing the [esc] key while the mouse cursor 
  1168. Xis inside the display area. The selection menu can be updated by 
  1169. Xentering a new filename on the 'File:' line and pressing the [Update_Menu] 
  1170. Xbutton. Changing the filter or updating the filter options used can be 
  1171. Xdone by editing the 'Filter:' line and pressing the [Update_filter] button.
  1172. X(These lines many contain shell wildcard characters.)  
  1173. X.SH OPTIONS
  1174. X.TP
  1175. X\fB-f\fP \fIfilter\fP
  1176. XSpecify a filter vue is to pipe the selected file thru before
  1177. Xdisplaying it. Using 'zcat' as a filter, vue can display the contents 
  1178. Xof compressed rasterfiles. Using Patrick J. Naughton's gif2ras program, 
  1179. Xvue can be used to display GIF files.
  1180. X.SH AUTHOR
  1181. X.nf
  1182. XMatthew Lee Stier
  1183. XSun Microsystems
  1184. X2000 Aerial Center, Suite 110
  1185. XMorrisville, NC 27560
  1186. X(919) 469-8300
  1187. X.fi
  1188. X.SH CREDITS
  1189. XVue was developed from a program publically called rastershow.
  1190. XRastershow's author is: David DiGiacomo, also an employee of Sun Microsystems
  1191. X.SH NOTES
  1192. XVue expects filters to accept input via stdin, and output the rasterfile 
  1193. Xvia stdout. If the filter you intend to use requires command-line option, 
  1194. Xthese need to included with the filter argument by enclosing it in single quotes. 
  1195. X
  1196. X    vue -f 'filter -options' filename filename....
  1197. X
  1198. XAny filter you specify must be reachable using your $PATH enviromental variable, 
  1199. Xor you must specify the the filters full path/filename.
  1200. X
  1201. XVue does do rudimentary dithering. This is to permit the viewing of color images
  1202. Xon monochrome workstations, and 24-bit images on 8-bit color displays.
  1203. SHAR_EOF
  1204. chmod 0777 vue.man || echo "restore of vue.man fails"
  1205. fi
  1206. if test -f gif2ras.c; then echo "File gif2ras.c exists"; else
  1207. echo "x - extracting gif2ras.c (Text)"
  1208. sed 's/^X//' << 'SHAR_EOF' > gif2ras.c &&
  1209. X#ifndef lint
  1210. Xstatic char sccsid[] = "@(#)gif2ras.c 1.1 89/01/17";
  1211. X#endif
  1212. X/*-
  1213. X * gif2ras.c - Converts from a Compuserve GIF (tm) image to a Sun Raster image.
  1214. X *
  1215. X * Copyright (c) 1988, 1989 by Patrick J. Naughton
  1216. X *
  1217. X * Author: Patrick J. Naughton
  1218. X * naughton@wind.sun.com
  1219. X *
  1220. X * Permission to use, copy, modify, and distribute this software and its
  1221. X * documentation for any purpose and without fee is hereby granted,
  1222. X * provided that the above copyright notice appear in all copies and that
  1223. X * both that copyright notice and this permission notice appear in
  1224. X * supporting documentation.
  1225. X *
  1226. X * This file is provided AS IS with no warranties of any kind.  The author
  1227. X * shall have no liability with respect to the infringement of copyrights,
  1228. X * trade secrets or any patents by this file or any part thereof.  In no
  1229. X * event will the author be liable for any lost revenue or profits or
  1230. X * other special, indirect and consequential damages.
  1231. X *
  1232. X * Comments and additions should be sent to the author:
  1233. X *
  1234. X *                     Patrick J. Naughton
  1235. X *                     Sun Microsystems
  1236. X *                     2550 Garcia Ave, MS 14-40
  1237. X *                     Mountain View, CA 94043
  1238. X *                     (415) 336-1080
  1239. X *
  1240. X * Revision History:
  1241. X * 01-Jan-89: Added error checking and removed NEXTSHORT.
  1242. X * 07-Sep-88: Added BytesPerScanline fix.
  1243. X * 30-Aug-88: Allow stdin/stdout. Restructured argument parser.
  1244. X * 27-Jul-88: Updated to use libpixrect to fix 386i byteswapping problems.
  1245. X * 11-Apr-88: Converted to C and changed to write Sun rasterfiles.
  1246. X * 19-Jan-88: GIFSLOW.PAS posted to comp.graphics by Jim Briebel,
  1247. X *            a Turbo Pascal 4.0 program to painfully slowly display
  1248. X *            GIF images on an EGA equipped IBM-PC.
  1249. X *
  1250. X * Description:
  1251. X *   This program takes a Compuserve "Graphics Interchange Format" or "GIF"
  1252. X * file as input and writes a file known as a Sun rasterfile.  This datafile
  1253. X * can be loaded by the NeWS "readcanvas" operator and is of the same format
  1254. X * as the files in /usr/NeWS/smi/*.  Under X11R2 there is a program called
  1255. X * xraster to display these files.
  1256. X *
  1257. X * Portability:
  1258. X *   To make this program convert to some image format other than Sun's
  1259. X * Rasterfile format simply seach for the tag "SS:" in the source and
  1260. X * replace these simple mechanisms with the appropriate ones for the
  1261. X * other output format.  I have marked all (six) Sun Specific pieces
  1262. X * of code with this comment.
  1263. X *
  1264. X * SS: compile with "cc -o gif2ras -O gif2ras.c -lpixrect"
  1265. X */
  1266. X
  1267. X#include <stdio.h>
  1268. X#include <pixrect/pixrect_hs.h> /* SS: main Pixrect header file */
  1269. X
  1270. Xtypedef int boolean;
  1271. X#define True (1)
  1272. X#define False (0)
  1273. X
  1274. X#define NEXTBYTE (*ptr++)
  1275. X#define IMAGESEP 0x2c
  1276. X#define INTERLACEMASK 0x40
  1277. X#define COLORMAPMASK 0x80
  1278. X
  1279. XFILE *fp;
  1280. X
  1281. Xint BitOffset = 0,        /* Bit Offset of next code */
  1282. X    XC = 0, YC = 0,        /* Output X and Y coords of current pixel */
  1283. X    Pass = 0,            /* Used by output routine if interlaced pic */
  1284. X    OutCount = 0,        /* Decompressor output 'stack count' */
  1285. X    RWidth, RHeight,        /* screen dimensions */
  1286. X    Width, Height,        /* image dimensions */
  1287. X    LeftOfs, TopOfs,        /* image offset */
  1288. X    BitsPerPixel,        /* Bits per pixel, read from GIF header */
  1289. X    BytesPerScanline,        /* bytes per scanline in output raster */
  1290. X    ColorMapSize,        /* number of colors */
  1291. X    CodeSize,            /* Code size, read from GIF header */
  1292. X    InitCodeSize,        /* Starting code size, used during Clear */
  1293. X    Code,            /* Value returned by ReadCode */
  1294. X    MaxCode,            /* limiting value for current code size */
  1295. X    ClearCode,            /* GIF clear code */
  1296. X    EOFCode,            /* GIF end-of-information code */
  1297. X    CurCode, OldCode, InCode,    /* Decompressor variables */
  1298. X    FirstFree,            /* First free code, generated per GIF spec */
  1299. X    FreeCode,            /* Decompressor, next free slot in hash table */
  1300. X    FinChar,            /* Decompressor variable */
  1301. X    BitMask,            /* AND mask for data size */
  1302. X    ReadMask;            /* Code AND mask for current code size */
  1303. X
  1304. Xboolean Interlace, HasColormap;
  1305. Xboolean Verbose = False;
  1306. X
  1307. X/* SS: defined in pixrect/pixrect_hs.h */
  1308. XPixrect *Output;        /* The Sun Pixrect */
  1309. Xcolormap_t Colormap;        /* The Pixrect Colormap */
  1310. X
  1311. Xu_char *Image;            /* The result array */
  1312. Xu_char *RawGIF;            /* The heap array to hold it, raw */
  1313. Xu_char *Raster;            /* The raster data stream, unblocked */
  1314. X
  1315. X    /* The hash table used by the decompressor */
  1316. Xint Prefix[4096];
  1317. Xint Suffix[4096];
  1318. X
  1319. X    /* An output array used by the decompressor */
  1320. Xint OutCode[1025];
  1321. X
  1322. X    /* The color map, read from the GIF header */
  1323. Xu_char Red[256], Green[256], Blue[256];
  1324. X
  1325. Xchar *id = "GIF87a";
  1326. X
  1327. Xchar *pname;            /* program name (used for error messages) */
  1328. X 
  1329. Xvoid
  1330. Xerror(s1, s2)
  1331. Xchar *s1, *s2;
  1332. X{
  1333. X    fprintf(stderr, s1, pname, s2);
  1334. X    exit(1);
  1335. X}
  1336. X
  1337. Xvoid
  1338. Xusage()
  1339. X{
  1340. X    error("usage: %s -[vq] [-|GIFfile] [rasterfile]\n", NULL);
  1341. X}
  1342. X
  1343. X
  1344. Xmain(argc, argv)
  1345. Xint argc;
  1346. Xchar *argv[];
  1347. X{
  1348. Xchar *inf = NULL;
  1349. Xchar *outf = NULL;
  1350. Xint filesize;
  1351. Xregister u_char ch, ch1;
  1352. Xregister u_char *ptr, *ptr1;
  1353. Xregister int i;
  1354. X
  1355. X    setbuf(stderr, NULL);
  1356. X    pname = argv[0];
  1357. X
  1358. X    while (--argc)
  1359. X    if ((++argv)[0][0] == '-')
  1360. X        switch (argv[0][1]) {
  1361. X        case 'v':
  1362. X        Verbose = True;
  1363. X        break;
  1364. X        case 'q':
  1365. X        usage();
  1366. X        case '\0':
  1367. X        if (inf == NULL)
  1368. X            inf = "Standard Input";
  1369. X        else if (outf == NULL)
  1370. X            outf = "Standard Output";
  1371. X        else
  1372. X            usage();
  1373. X        break;
  1374. X        default:
  1375. X        fprintf(stderr, "%s: illegal option -%c.\n", pname,
  1376. X            argv[0][1]);
  1377. X        exit(1);
  1378. X        }
  1379. X    else if (inf == NULL)
  1380. X        inf = argv[0];
  1381. X    else if (outf == NULL)
  1382. X        outf = argv[0];
  1383. X    else
  1384. X        usage();
  1385. X
  1386. X    if (inf == NULL || strcmp(inf, "Standard Input") == 0) {
  1387. X    inf = "Standard Input";
  1388. X    fp = stdin;
  1389. X    } else if (!(fp = fopen(inf, "r")))
  1390. X    error("%s: %s not found.\n", inf);
  1391. X
  1392. X    /* find the size of the file */
  1393. X    fseek(fp, 0L, 2);
  1394. X    filesize = ftell(fp);
  1395. X    fseek(fp, 0L, 0);
  1396. X
  1397. X    if (!(ptr = RawGIF = (u_char *) malloc(filesize)))
  1398. X    error("%s: not enough memory to read gif file.\n", NULL);
  1399. X
  1400. X    if (!(Raster = (u_char *) malloc(filesize)))
  1401. X    error("%s: not enough memory to read gif file.\n", NULL);
  1402. X
  1403. X    if (fread(ptr, filesize, 1, fp) != 1)
  1404. X    error("%s: GIF data read failed\n", NULL);
  1405. X
  1406. X    if (strncmp(ptr, id, 6))
  1407. X    error("%s: %s is not a GIF file.\n", inf);
  1408. X    ptr += 6;
  1409. X
  1410. X/* Get variables from the GIF screen descriptor */
  1411. X
  1412. X    ch = NEXTBYTE;
  1413. X    RWidth = ch + 0x100 * NEXTBYTE;    /* screen dimensions... not used. */
  1414. X    ch = NEXTBYTE;
  1415. X    RHeight = ch + 0x100 * NEXTBYTE;
  1416. X
  1417. X    if (Verbose)
  1418. X    fprintf(stderr, "screen dims: %dx%d.\n", RWidth, RHeight);
  1419. X
  1420. X    ch = NEXTBYTE;
  1421. X    HasColormap = ((ch & COLORMAPMASK) ? True : False);
  1422. X
  1423. X    BitsPerPixel = (ch & 7) + 1;
  1424. X    ColorMapSize = 1 << BitsPerPixel;
  1425. X    BitMask = ColorMapSize - 1;
  1426. X
  1427. X    ch = NEXTBYTE;        /* background color... not used. */
  1428. X
  1429. X    if (NEXTBYTE)        /* supposed to be NULL */
  1430. X    error("%s: %s is a corrupt GIF file (nonull).\n", inf);
  1431. X
  1432. X/* Read in global colormap. */
  1433. X
  1434. X    if (HasColormap) {
  1435. X    if (Verbose)
  1436. X        fprintf(stderr, "%s is %d bits per pixel, (%d colors).\n",
  1437. X        inf, BitsPerPixel, ColorMapSize);
  1438. X    for (i = 0; i < ColorMapSize; i++) {
  1439. X        Red[i] = NEXTBYTE;
  1440. X        Green[i] = NEXTBYTE;
  1441. X        Blue[i] = NEXTBYTE;
  1442. X    }
  1443. X
  1444. X/* SS: Fill in the Pixrect colormap struct */
  1445. X    Colormap.type = RMT_EQUAL_RGB;
  1446. X    Colormap.length = ColorMapSize;
  1447. X    Colormap.map[0] = Red;
  1448. X    Colormap.map[1] = Green;
  1449. X    Colormap.map[2] = Blue;
  1450. X    }
  1451. X    else error("%s: %s does not have a colormap.\n", inf);
  1452. X
  1453. X
  1454. X/* Check for image seperator */
  1455. X
  1456. X    if (NEXTBYTE != IMAGESEP)
  1457. X    error("%s: %s is a corrupt GIF file (nosep).\n", inf);
  1458. X
  1459. X/* Now read in values from the image descriptor */
  1460. X
  1461. X    ch = NEXTBYTE;
  1462. X    LeftOfs = ch + 0x100 * NEXTBYTE;
  1463. X    ch = NEXTBYTE;
  1464. X    TopOfs = ch + 0x100 * NEXTBYTE;
  1465. X    ch = NEXTBYTE;
  1466. X    Width = ch + 0x100 * NEXTBYTE;
  1467. X    ch = NEXTBYTE;
  1468. X    Height = ch + 0x100 * NEXTBYTE;
  1469. X    Interlace = ((NEXTBYTE & INTERLACEMASK) ? True : False);
  1470. X
  1471. X    if (Verbose)
  1472. X    fprintf(stderr, "Reading a %d by %d %sinterlaced image...",
  1473. X        Width, Height, (Interlace) ? "" : "non-");
  1474. X    
  1475. X
  1476. X/* Note that I ignore the possible existence of a local color map.
  1477. X * I'm told there aren't many files around that use them, and the spec
  1478. X * says it's defined for future use.  This could lead to an error
  1479. X * reading some files. 
  1480. X */
  1481. X
  1482. X/* Start reading the raster data. First we get the intial code size
  1483. X * and compute decompressor constant values, based on this code size.
  1484. X */
  1485. X
  1486. X    CodeSize = NEXTBYTE;
  1487. X    ClearCode = (1 << CodeSize);
  1488. X    EOFCode = ClearCode + 1;
  1489. X    FreeCode = FirstFree = ClearCode + 2;
  1490. X
  1491. X/* The GIF spec has it that the code size is the code size used to
  1492. X * compute the above values is the code size given in the file, but the
  1493. X * code size used in compression/decompression is the code size given in
  1494. X * the file plus one. (thus the ++).
  1495. X */
  1496. X
  1497. X    CodeSize++;
  1498. X    InitCodeSize = CodeSize;
  1499. X    MaxCode = (1 << CodeSize);
  1500. X    ReadMask = MaxCode - 1;
  1501. X
  1502. X/* Read the raster data.  Here we just transpose it from the GIF array
  1503. X * to the Raster array, turning it from a series of blocks into one long
  1504. X * data stream, which makes life much easier for ReadCode().
  1505. X */
  1506. X
  1507. X    ptr1 = Raster;
  1508. X    do {
  1509. X    ch = ch1 = NEXTBYTE;
  1510. X    while (ch--) *ptr1++ = NEXTBYTE;
  1511. X    if ((ptr1 - Raster ) > filesize)
  1512. X        error("%s: %s is a corrupt GIF file (unblock).\n", inf);
  1513. X    } while(ch1);
  1514. X
  1515. X    free(RawGIF);        /* We're done with the raw data now... */
  1516. X
  1517. X    if (Verbose) {
  1518. X    fprintf(stderr, "done.\n");
  1519. X    fprintf(stderr, "Decompressing...");
  1520. X    }
  1521. X
  1522. X
  1523. X/* SS: Allocate the Sun Pixrect and make "Image" point to the image data. */
  1524. X    Output = mem_create(Width, Height, 8);
  1525. X    if (Output == (Pixrect *) NULL)
  1526. X    error("%s: not enough memory for output data.\n", NULL);
  1527. X    Image = (u_char *) mpr_d(Output)->md_image;
  1528. X    BytesPerScanline = mpr_d(Output)->md_linebytes;
  1529. X
  1530. X
  1531. X/* Decompress the file, continuing until you see the GIF EOF code.
  1532. X * One obvious enhancement is to add checking for corrupt files here.
  1533. X */
  1534. X
  1535. X    Code = ReadCode();
  1536. X    while (Code != EOFCode) {
  1537. X
  1538. X/* Clear code sets everything back to its initial value, then reads the
  1539. X * immediately subsequent code as uncompressed data.
  1540. X */
  1541. X
  1542. X    if (Code == ClearCode) {
  1543. X        CodeSize = InitCodeSize;
  1544. X        MaxCode = (1 << CodeSize);
  1545. X        ReadMask = MaxCode - 1;
  1546. X        FreeCode = FirstFree;
  1547. X        CurCode = OldCode = Code = ReadCode();
  1548. X        FinChar = CurCode & BitMask;
  1549. X        AddToPixel(FinChar);
  1550. X    }
  1551. X    else {
  1552. X
  1553. X/* If not a clear code, then must be data: save same as CurCode and InCode */
  1554. X
  1555. X        CurCode = InCode = Code;
  1556. X
  1557. X/* If greater or equal to FreeCode, not in the hash table yet;
  1558. X * repeat the last character decoded
  1559. X */
  1560. X
  1561. X        if (CurCode >= FreeCode) {
  1562. X        CurCode = OldCode;
  1563. X        OutCode[OutCount++] = FinChar;
  1564. X        }
  1565. X
  1566. X/* Unless this code is raw data, pursue the chain pointed to by CurCode
  1567. X * through the hash table to its end; each code in the chain puts its
  1568. X * associated output code on the output queue.
  1569. X */
  1570. X
  1571. X        while (CurCode > BitMask) {
  1572. X        if (OutCount > 1024)
  1573. X            error("%s: %s is a corrupt GIF file (OutCount).\n", inf);
  1574. X        OutCode[OutCount++] = Suffix[CurCode];
  1575. X        CurCode = Prefix[CurCode];
  1576. X        }
  1577. X
  1578. X/* The last code in the chain is treated as raw data. */
  1579. X
  1580. X        FinChar = CurCode & BitMask;
  1581. X        OutCode[OutCount++] = FinChar;
  1582. X
  1583. X/* Now we put the data out to the Output routine.
  1584. X * It's been stacked LIFO, so deal with it that way...
  1585. X */
  1586. X
  1587. X        for (i = OutCount - 1; i >= 0; i--)
  1588. X        AddToPixel(OutCode[i]);
  1589. X        OutCount = 0;
  1590. X
  1591. X/* Build the hash table on-the-fly. No table is stored in the file. */
  1592. X
  1593. X        Prefix[FreeCode] = OldCode;
  1594. X        Suffix[FreeCode] = FinChar;
  1595. X        OldCode = InCode;
  1596. X
  1597. X/* Point to the next slot in the table.  If we exceed the current
  1598. X * MaxCode value, increment the code size unless it's already 12.  If it
  1599. X * is, do nothing: the next code decompressed better be CLEAR
  1600. X */
  1601. X
  1602. X        FreeCode++;
  1603. X        if (FreeCode >= MaxCode) {
  1604. X        if (CodeSize < 12) {
  1605. X            CodeSize++;
  1606. X            MaxCode *= 2;
  1607. X            ReadMask = (1 << CodeSize) - 1;
  1608. X        }
  1609. X        }
  1610. X    }
  1611. X    Code = ReadCode();
  1612. X    }
  1613. X
  1614. X    free(Raster);
  1615. X
  1616. X    if (Verbose)
  1617. X    fprintf(stderr, "done.\n");
  1618. X
  1619. X    if (fp != stdin)
  1620. X    fclose(fp);
  1621. X
  1622. X    if (outf == NULL || strcmp(outf, "Standard Output") == 0) {
  1623. X    outf = "Standard Output";
  1624. X    fp = stdout;
  1625. X    }
  1626. X    else {
  1627. X    if (!(fp = fopen(outf, "w")))
  1628. X        error("%s: %s couldn't be opened for writing.\n", outf);
  1629. X    }
  1630. X
  1631. X    if (Verbose)
  1632. X    fprintf(stderr, "Writing rasterfile in %s...", outf);
  1633. X
  1634. X/* SS: Pixrect Rasterfile output code. */
  1635. X    if (pr_dump(Output, fp, &Colormap, RT_STANDARD, 0) == PIX_ERR)
  1636. X    error("%s: error writing Sun Rasterfile: %s\n", outf);
  1637. X
  1638. X    if (Verbose)
  1639. X    fprintf(stderr, "done.\n");
  1640. X
  1641. X    pr_destroy(Output);
  1642. X
  1643. X    if (fp != stdout)
  1644. X    fclose(fp);
  1645. X
  1646. X    exit(0);
  1647. X}
  1648. X
  1649. X
  1650. X/* Fetch the next code from the raster data stream.  The codes can be
  1651. X * any length from 3 to 12 bits, packed into 8-bit bytes, so we have to
  1652. X * maintain our location in the Raster array as a BIT Offset.  We compute
  1653. X * the byte Offset into the raster array by dividing this by 8, pick up
  1654. X * three bytes, compute the bit Offset into our 24-bit chunk, shift to
  1655. X * bring the desired code to the bottom, then mask it off and return it. 
  1656. X */
  1657. XReadCode()
  1658. X{
  1659. Xint RawCode, ByteOffset;
  1660. X
  1661. X    ByteOffset = BitOffset / 8;
  1662. X    RawCode = Raster[ByteOffset] + (0x100 * Raster[ByteOffset + 1]);
  1663. X    if (CodeSize >= 8)
  1664. X    RawCode += (0x10000 * Raster[ByteOffset + 2]);
  1665. X    RawCode >>= (BitOffset % 8);
  1666. X    BitOffset += CodeSize;
  1667. X    return(RawCode & ReadMask);
  1668. X}
  1669. X
  1670. X
  1671. XAddToPixel(Index)
  1672. Xu_char Index;
  1673. X{
  1674. X    *(Image + YC * BytesPerScanline + XC) = Index;
  1675. X
  1676. X/* Update the X-coordinate, and if it overflows, update the Y-coordinate */
  1677. X
  1678. X    if (++XC == Width) {
  1679. X
  1680. X/* If a non-interlaced picture, just increment YC to the next scan line. 
  1681. X * If it's interlaced, deal with the interlace as described in the GIF
  1682. X * spec.  Put the decoded scan line out to the screen if we haven't gone
  1683. X * past the bottom of it
  1684. X */
  1685. X
  1686. X    XC = 0;
  1687. X    if (!Interlace) YC++;
  1688. X    else {
  1689. X        switch (Pass) {
  1690. X        case 0:
  1691. X            YC += 8;
  1692. X            if (YC >= Height) {
  1693. X            Pass++;
  1694. X            YC = 4;
  1695. X            }
  1696. X        break;
  1697. X        case 1:
  1698. X            YC += 8;
  1699. X            if (YC >= Height) {
  1700. X            Pass++;
  1701. X            YC = 2;
  1702. X            }
  1703. X        break;
  1704. X        case 2:
  1705. X            YC += 4;
  1706. X            if (YC >= Height) {
  1707. X            Pass++;
  1708. X            YC = 1;
  1709. X            }
  1710. X        break;
  1711. X        case 3:
  1712. X            YC += 2;
  1713. X        break;
  1714. X        default:
  1715. X        break;
  1716. X        }
  1717. X    }
  1718. X    }
  1719. X}
  1720. SHAR_EOF
  1721. chmod 0644 gif2ras.c || echo "restore of gif2ras.c fails"
  1722. fi
  1723. if test -f gif2ras.man; then echo "File gif2ras.man exists"; else
  1724. echo "x - extracting gif2ras.man (Text)"
  1725. sed 's/^X//' << 'SHAR_EOF' > gif2ras.man &&
  1726. X.TH GIF2SUN L
  1727. X.SH NAME
  1728. Xgif2sun \- GIF to Sun rasterfile filter
  1729. X.SH SYNOPSIS
  1730. X\fBgif2sun\fP [\fB-v\fP] [\fB-q\fP] [\fB-\fP|\fBGIFfile\fP] [\fBrasterfile\fP]
  1731. X.SH DESCRIPTION
  1732. XGenerate the rasterfile equivalent of a GIF image.
  1733. X.SH OPTIONS
  1734. X.TP
  1735. X.nf
  1736. X\fB-v\fP
  1737. XSet verbose mode. 
  1738. X(Reports status of program via stderr.)
  1739. X.fi
  1740. X.TP
  1741. X.nf
  1742. X\fB-q\fP
  1743. XDisplay help message. 
  1744. X(Usage prompt.)
  1745. X.fi
  1746. X.TP
  1747. X.nf
  1748. X\fB-\fP
  1749. XForce sourcing of GIF file from stdin. 
  1750. X(Only needed when sourcing the GIF file from \fBstdin\fP and 
  1751. Xspecifying the output rasterfile on the command line.)
  1752. X.fi
  1753. X.SH DIAGNOSTICS
  1754. XSee verbose mode above.
  1755. X.SH AUTHOR
  1756. X.nf
  1757. XPatrick J. Naughton
  1758. XSun Microsystems
  1759. X2550 Garcia Ave, MS 14-40
  1760. XMountain View, CA 94043
  1761. X(415) 336-1080
  1762. X.fi
  1763. SHAR_EOF
  1764. chmod 0644 gif2ras.man || echo "restore of gif2ras.man fails"
  1765. fi
  1766. exit 0
  1767.  
  1768. -- 
  1769. Matthew Lee Stier    (mstier@east.Sun.COM)   |
  1770. Sun Microsystems ---  RTP, NC  27709-3447    |     "Wisconsin   Escapee"
  1771. uucp:  sun!mstier or mcnc!rti!sunpix!matthew |
  1772. phone: (919) 469-8300 fax: (919) 460-8355    |
  1773.