home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume5 / xview.demos / part03 < prev    next >
Text File  |  1989-12-07  |  57KB  |  1,748 lines
  1. Path: uunet!island!sun.com
  2. From: argv@sun.com (Dan Heller)
  3. Newsgroups: comp.sources.x
  4. Subject: v05i041: XView example programs, Part03/06
  5. Message-ID: <1241@island.uu.net>
  6. Date: 8 Dec 89 07:38:06 GMT
  7. Sender: argv@island.uu.net
  8. Lines: 1737
  9. Approved: island!argv@sun.com
  10.  
  11. Submitted-by: Dan Heller <argv@sun.com>
  12. Posting-number: Volume 5, Issue 41
  13. Archive-name: xview.demos/part03
  14.  
  15.  
  16.  
  17. #! /bin/sh
  18. # This is a shell archive.  Remove anything before this line, then feed it
  19. # into a shell via "sh file" or similar.  To overwrite existing files,
  20. # type "sh file -c".
  21. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  22. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  23. # If this archive is complete, you will see the following message at the end:
  24. #        "End of archive 3 (of 6)."
  25. # Contents:  xview.demos/canvas/canvas_event.c
  26. #   xview.demos/color/color_animate.c xview.demos/color/color_logo.c
  27. #   xview.demos/menus/menu_dir.c xview.demos/misc/drag_n_drop.c
  28. #   xview.demos/notice/notice.c xview.demos/notifier/ntfy_pipe.c
  29. #   xview.demos/panels/choices.c xview.demos/seln_svc/text_seln.c
  30. #   xview.demos/textsw/textsw.font.c
  31. # Wrapped by argv@island on Thu Dec  7 23:18:19 1989
  32. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  33. if test -f 'xview.demos/canvas/canvas_event.c' -a "${1}" != "-c" ; then 
  34.   echo shar: Will not clobber existing file \"'xview.demos/canvas/canvas_event.c'\"
  35. else
  36. echo shar: Extracting \"'xview.demos/canvas/canvas_event.c'\" \(4710 characters\)
  37. sed "s/^X//" >'xview.demos/canvas/canvas_event.c' <<'END_OF_FILE'
  38. X/*
  39. X *  canvas_event.c
  40. X *  Demonstrates how to get keyboard and mouse events in an canvas
  41. X *  window.  Looks for keyboards, pointer movement and button
  42. X *  events and displays the info in the canvas.
  43. X */
  44. X#include <X11/Xlib.h>
  45. X#include <xview/xview.h>
  46. X#include <xview/canvas.h>
  47. X#include <xview/xv_xrect.h>
  48. X
  49. Xvoid    event_proc(), repaint_proc();
  50. Xchar    kbd_msg[128], ptr_msg[128], but_msg[128];
  51. X
  52. X/*
  53. X * main()
  54. X *      Create a canvas specifying a repaint procedure.
  55. X *      Get the paint window for the canvas and set the input
  56. X *      mask and the event procedure.
  57. X */
  58. Xmain(argc, argv)
  59. Xint argc;
  60. Xchar *argv[];
  61. X{
  62. X    Frame       frame;
  63. X    Canvas      canvas;
  64. X
  65. X    /* Initialize XView */
  66. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  67. X
  68. X    /* Create windows -- base frame and canvas. */
  69. X    frame = (Frame)xv_create(NULL, FRAME, NULL);
  70. X
  71. X    canvas = (Canvas)xv_create(frame, CANVAS,
  72. X        XV_WIDTH,               300,
  73. X        XV_HEIGHT,              110,
  74. X        CANVAS_X_PAINT_WINDOW,  TRUE,
  75. X        CANVAS_REPAINT_PROC,    repaint_proc,
  76. X        NULL);
  77. X    window_fit(frame);
  78. X
  79. X    /* Set input mask */
  80. X    xv_set(canvas_paint_window(canvas),
  81. X        WIN_EVENT_PROC,         event_proc,
  82. X        WIN_CONSUME_EVENTS,
  83. X            KBD_DONE, KBD_USE, LOC_DRAG, LOC_MOVE, LOC_WINENTER,
  84. X            LOC_WINEXIT, WIN_ASCII_EVENTS, WIN_MOUSE_BUTTONS,
  85. X            NULL,
  86. X        NULL);
  87. X
  88. X    /* Initial messages */
  89. X    strcpy(kbd_msg, "Keyboard: key press events");
  90. X    strcpy(ptr_msg, "Pointer: pointer movement events");
  91. X    strcpy(but_msg, "Button: button press events");
  92. X
  93. X    /* Start event loop */
  94. X    xv_main_loop(frame);
  95. X}
  96. X
  97. X/*
  98. X * event_proc()
  99. X *      Called when an event is received in the canvas window.
  100. X *      Updates the keyboard, pointer and button message strings
  101. X *      and then calls repaint_proc() to paint them to the window.
  102. X */
  103. Xvoid
  104. Xevent_proc(window, event)
  105. XXv_Window window;
  106. XEvent    *event;
  107. X{
  108. X    if (event_is_ascii(event))
  109. X        sprintf(kbd_msg, "Keyboard: key '%c' %d pressed at %d,%d",
  110. X                event_action(event), event_action(event),
  111. X                event_x(event), event_y(event));
  112. X    else
  113. X        switch (event_action(event)) {
  114. X            case KBD_USE:
  115. X                sprintf(kbd_msg, "Keyboard: got keyboard focus");
  116. X                break;
  117. X            case KBD_DONE:
  118. X                sprintf(kbd_msg, "Keyboard: lost keyboard focus");
  119. X                break;
  120. X            case LOC_MOVE:
  121. X                sprintf(ptr_msg, "Pointer: moved to %d,%d",
  122. X                    event_x(event), event_y(event));
  123. X                break;
  124. X            case LOC_DRAG:
  125. X                sprintf(ptr_msg, "Pointer: dragged to %d,%d",
  126. X                    event_x(event), event_y(event));
  127. X                break;
  128. X            case LOC_WINENTER:
  129. X                sprintf(ptr_msg, "Pointer: entered window at %d,%d",
  130. X                    event_x(event), event_y(event));
  131. X                break;
  132. X            case LOC_WINEXIT:
  133. X                sprintf(ptr_msg, "Pointer: exited window at %d,%d",
  134. X                    event_x(event), event_y(event));
  135. X                break;
  136. X            case ACTION_SELECT:
  137. X            case MS_LEFT:
  138. X                sprintf(but_msg, "Button: Select (Left) at %d,%d",
  139. X                    event_x(event), event_y(event));
  140. X                break;
  141. X            case ACTION_ADJUST:
  142. X            case MS_MIDDLE:
  143. X                sprintf(but_msg, "Button: Adjust (Middle) at %d,%d",
  144. X                    event_x(event), event_y(event));
  145. X                break;
  146. X            case ACTION_MENU:
  147. X            case MS_RIGHT:
  148. X                sprintf(but_msg, "Button: Menu (Right) at %d,%d",
  149. X                    event_x(event), event_y(event));
  150. X                break;
  151. X            default:
  152. X                return;
  153. X        }
  154. X
  155. X    /* call repaint proc directly to update messages */
  156. X    repaint_proc((Canvas)NULL, window,
  157. X        (Display *)xv_get(window, XV_DISPLAY),
  158. X        xv_get(window, XV_XID), (Xv_xrectlist *) NULL);
  159. X}
  160. X
  161. X/*
  162. X * repaint_proc()
  163. X *      Called to repaint the canvas in response to damage events
  164. X *      and the initial painting of the canvas window.
  165. X *      Displays the keyboard, pointer and button message strings
  166. X *      after erasing the previous messages.
  167. X */
  168. Xvoid
  169. Xrepaint_proc(canvas, paint_window, dpy, xwin, xrects)
  170. XCanvas        canvas;           /* Ignored */
  171. XXv_Window     paint_window;     /* Ignored */
  172. XDisplay      *dpy;
  173. XWindow        xwin;
  174. XXv_xrectlist *xrects;           /* Ignored */
  175. X{
  176. X    GC gc = DefaultGC(dpy, DefaultScreen(dpy));
  177. X
  178. X    XClearWindow(dpy, xwin);
  179. X    XDrawString(dpy, xwin, gc, 25, 25, kbd_msg, strlen(kbd_msg));
  180. X    XDrawString(dpy, xwin, gc, 25, 50, ptr_msg, strlen(ptr_msg));
  181. X    XDrawString(dpy, xwin, gc, 25, 75, but_msg, strlen(but_msg));
  182. X}
  183. END_OF_FILE
  184. if test 4710 -ne `wc -c <'xview.demos/canvas/canvas_event.c'`; then
  185.     echo shar: \"'xview.demos/canvas/canvas_event.c'\" unpacked with wrong size!
  186. fi
  187. # end of 'xview.demos/canvas/canvas_event.c'
  188. fi
  189. if test -f 'xview.demos/color/color_animate.c' -a "${1}" != "-c" ; then 
  190.   echo shar: Will not clobber existing file \"'xview.demos/color/color_animate.c'\"
  191. else
  192. echo shar: Extracting \"'xview.demos/color/color_animate.c'\" \(5359 characters\)
  193. sed "s/^X//" >'xview.demos/color/color_animate.c' <<'END_OF_FILE'
  194. X/*
  195. X * color_animate.c -- use glyphs from the "icon" font distributed
  196. X * with XView to do frame-by-frame animation.
  197. X */
  198. X#include <stdio.h>
  199. X#include <ctype.h>
  200. X#include <X11/X.h>
  201. X#include <X11/Xlib.h>
  202. X#include <X11/Xos.h>        /* for <sys/time.h> */
  203. X#include <xview/xview.h>
  204. X#include <xview/panel.h>
  205. X#include <xview/font.h>
  206. X#include <xview/notify.h>
  207. X#include <xview/cms.h>
  208. X
  209. XFrame          frame;
  210. XCanvas          canvas;
  211. XDisplay         *dpy;
  212. XGC          gc;
  213. XWindow          canvas_win;
  214. XNotify_value      animate();
  215. Xstruct itimerval  timer;
  216. X
  217. X#define ArraySize(x)  (sizeof(x)/sizeof(x[0]))
  218. Xchar *horses[] = { "N", "O", "P", "Q", "R" };
  219. Xchar *eyes[] = { "2", "5", "4", "3", "4", "5", "2", "1", "0", "/", "0", "1" };
  220. Xchar *boys[] = { "\007", "\005", "\007", "\010" };
  221. Xchar *men[] = { "\\", "]", "Y", "Z", "[" };
  222. X
  223. X/* indices into color table renders specified colors. */
  224. X#define WHITE   0
  225. X#define RED     1
  226. X#define GREEN   2
  227. X#define BLUE    3
  228. X#define ORANGE  4
  229. X#define AQUA    5
  230. X#define PINK    6
  231. X#define BLACK   7
  232. X#define RANDOM_COLOR   8
  233. X
  234. Xint max_images = ArraySize(horses);
  235. Xchar **images = horses;
  236. Xint cnt;
  237. X
  238. Xmain(argc, argv)
  239. Xint    argc;
  240. Xchar    *argv[];
  241. X{
  242. X    unsigned char red[8], green[8], blue[8];
  243. X    Panel    panel;
  244. X    XGCValues    gcvalues;
  245. X    Xv_Font    _font;
  246. X    XFontStruct *font;
  247. X    void    start_stop(), adjust_speed(), change_glyph();
  248. X    Xv_cmsdata  cms_data;
  249. X    long    *colors;
  250. X    extern void    exit();
  251. X
  252. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  253. X
  254. X    /* initialize RGB values for specified colors */
  255. X    red[WHITE] = 255;   green[WHITE] = 255;   blue[WHITE] = 255;
  256. X    red[RED] = 255;     green[RED] = 0;       blue[RED] = 0;
  257. X    red[GREEN] = 0;     green[GREEN] = 255;   blue[GREEN] = 50;
  258. X    red[BLUE] = 10;     green[BLUE] = 50;     blue[BLUE] = 255;
  259. X    red[ORANGE] = 250;  green[ORANGE] = 130;  blue[ORANGE] = 80;
  260. X    red[AQUA] = 30;     green[AQUA] = 230;    blue[AQUA] = 250;
  261. X    red[PINK] = 230;    green[PINK] = 30;     blue[PINK] = 250;
  262. X
  263. X    cms_data.type = XV_STATIC_CMS;
  264. X    cms_data.size = 8;
  265. X    cms_data.rgb_count = 8;
  266. X    cms_data.index = 0;
  267. X    cms_data.red = red;
  268. X    cms_data.green = green;
  269. X    cms_data.blue = blue;
  270. X
  271. X    frame = (Frame)xv_create(XV_NULL, FRAME,
  272. X    FRAME_LABEL,        argv[0],
  273. X    FRAME_SHOW_FOOTER,    TRUE,
  274. X    NULL);
  275. X
  276. X    panel = (Panel)xv_create(frame, PANEL,
  277. X    PANEL_LAYOUT,        PANEL_VERTICAL,
  278. X    WIN_CMS_NAME,        "panel",
  279. X    WIN_CMS_DATA,        &cms_data,
  280. X    NULL);
  281. X    xv_create(panel, PANEL_BUTTON,
  282. X    PANEL_LABEL_STRING,    "Quit",
  283. X    PANEL_NOTIFY_PROC,    exit,
  284. X    PANEL_ITEM_COLOR,    RED,
  285. X    NULL);
  286. X    xv_create(panel, PANEL_SLIDER,
  287. X    PANEL_LABEL_STRING,    "Millisecs Between Frames",
  288. X    PANEL_VALUE,        0,
  289. X    PANEL_MAX_VALUE,    120,
  290. X    PANEL_ITEM_COLOR,    BLUE,
  291. X    PANEL_NOTIFY_PROC,    adjust_speed,
  292. X    NULL);
  293. X    xv_create(panel, PANEL_CHOICE,
  294. X    PANEL_LABEL_STRING,    "Glyphs",
  295. X    PANEL_LAYOUT,        PANEL_HORIZONTAL,
  296. X    PANEL_DISPLAY_LEVEL,    PANEL_ALL,
  297. X    PANEL_CHOICE_STRINGS,    "Horse", "Man", "Boy", "Eye", NULL,
  298. X    PANEL_ITEM_COLOR,    GREEN,
  299. X    PANEL_NOTIFY_PROC,    change_glyph,
  300. X    NULL);
  301. X    window_fit(panel);
  302. X
  303. X    cms_data.type = XV_STATIC_CMS;
  304. X    cms_data.rgb_count = cms_data.size = 2;
  305. X    canvas = (Canvas)xv_create(frame, CANVAS,
  306. X    XV_WIDTH,        64,
  307. X    XV_HEIGHT,        64,
  308. X    WIN_CMS_NAME,        "rainbow",
  309. X    WIN_CMS_DATA,        &cms_data,
  310. X        CANVAS_X_PAINT_WINDOW,    TRUE,
  311. X        /* WIN_DYNAMIC_VISUAL,     TRUE, */
  312. X    CANVAS_RETAINED,    FALSE,
  313. X        NULL);
  314. X    canvas_win = (Window)xv_get(canvas_paint_window(canvas), XV_XID);
  315. X
  316. X    window_fit(frame);
  317. X
  318. X    dpy = (Display *)xv_get(frame, XV_DISPLAY);
  319. X    _font = (Xv_Font)xv_find(frame, FONT,
  320. X    FONT_NAME,    "icon",
  321. X    NULL);
  322. X    font = (XFontStruct *)xv_get(_font, FONT_INFO);
  323. X
  324. X    colors = (long *)xv_get(canvas, WIN_X_COLOR_INDICES);
  325. X    gcvalues.font = font->fid;
  326. X    gcvalues.graphics_exposures = False;
  327. X    gcvalues.foreground = colors[1];
  328. X    gcvalues.background = WhitePixel(dpy, DefaultScreen(dpy));
  329. X    gc = XCreateGC(dpy, RootWindow(dpy, DefaultScreen(dpy)),
  330. X    GCForeground | GCBackground | GCFont | GCGraphicsExposures,
  331. X    &gcvalues);
  332. X
  333. X    xv_main_loop(frame);
  334. X}
  335. X
  336. XNotify_value
  337. Xanimate()
  338. X{
  339. X    static unsigned char red, green, blue;
  340. X    Xv_cmsdata cms_data;
  341. X    long *colors;
  342. X
  343. X    red = (red+1) % 255;
  344. X    green = (green+2) % 255;
  345. X    blue = (blue+3) % 255;
  346. X
  347. X    cms_data.type = XV_STATIC_CMS;
  348. X    cms_data.size = 2;
  349. X    cms_data.rgb_count = 2;
  350. X    cms_data.index = 1;
  351. X    cms_data.red = &red;
  352. X    cms_data.green = &green;
  353. X    cms_data.blue = &blue;
  354. X    xv_set(canvas, WIN_CMS_DATA, &cms_data, NULL);
  355. X    colors = (long *)xv_get(canvas, WIN_X_COLOR_INDICES);
  356. X    XSetForeground(dpy, gc, colors[1]);
  357. X
  358. X    XDrawImageString(dpy, canvas_win, gc, 5, 40, images[cnt], 1);
  359. X    cnt = (cnt + 1) % max_images;
  360. X
  361. X    return NOTIFY_DONE;
  362. X}
  363. X
  364. Xvoid
  365. Xchange_glyph(item, value)
  366. XPanel_item item;
  367. Xint value;
  368. X{
  369. X    cnt = 0;
  370. X    if (value == 0) {
  371. X    max_images = ArraySize(horses);
  372. X    images = horses;
  373. X    } else if (value == 1) {
  374. X    max_images = ArraySize(men);
  375. X    images = men;
  376. X    } else if (value == 2) {
  377. X    max_images = ArraySize(boys);
  378. X    images = boys;
  379. X    } else if (value == 3) {
  380. X    max_images = ArraySize(eyes);
  381. X    images = eyes;
  382. X    }
  383. X    XClearWindow(dpy, canvas_win);
  384. X}
  385. X
  386. Xvoid
  387. Xadjust_speed(item, value)
  388. XPanel_item item;
  389. Xint value;
  390. X{
  391. X    if (value > 0) {
  392. X    timer.it_value.tv_usec = (value + 20) * 1000;
  393. X    timer.it_interval.tv_usec = (value + 20) * 1000;
  394. X    notify_set_itimer_func(frame, animate, ITIMER_REAL, &timer, NULL);
  395. X    } else
  396. X    /* turn it off */
  397. X    notify_set_itimer_func(frame, NULL, ITIMER_REAL, NULL, NULL);
  398. X}
  399. END_OF_FILE
  400. if test 5359 -ne `wc -c <'xview.demos/color/color_animate.c'`; then
  401.     echo shar: \"'xview.demos/color/color_animate.c'\" unpacked with wrong size!
  402. fi
  403. # end of 'xview.demos/color/color_animate.c'
  404. fi
  405. if test -f 'xview.demos/color/color_logo.c' -a "${1}" != "-c" ; then 
  406.   echo shar: Will not clobber existing file \"'xview.demos/color/color_logo.c'\"
  407. else
  408. echo shar: Extracting \"'xview.demos/color/color_logo.c'\" \(4703 characters\)
  409. sed "s/^X//" >'xview.demos/color/color_logo.c' <<'END_OF_FILE'
  410. X/*
  411. X * color_logo.c --
  412. X *  This program demonstrates the combined use of the XView color
  413. X *  model/API and Xlib graphics calls. The program uses XView to
  414. X *  create and manage its colormap segment while doing its actual
  415. X *  drawing using Xlib routines.
  416. X *  The program draws the X logo in red, green and blue in a canvas.
  417. X */
  418. X#include <X11/Xlib.h>
  419. X#include <X11/bitmaps/xlogo64>
  420. X#include <xview/xview.h>
  421. X#include <xview/canvas.h>
  422. X#include <xview/cms.h>
  423. X#include <xview/xv_xrect.h>
  424. X
  425. X/* Color indices */
  426. X#define WHITE           0
  427. X#define RED             1
  428. X#define GREEN           2
  429. X#define BLUE            3
  430. X#define NUM_COLORS      4
  431. X
  432. X/* graphics context used for rendering logos */
  433. XGC      gc;
  434. X
  435. X/* table of pixel values for colors */
  436. Xunsigned long    *pixel_table;
  437. X
  438. X/*
  439. X * Create a frame and a canvas.
  440. X * Allocate read-only colors (called a static colormap segment in
  441. X * XView parlance) and associate colors with the canvas.  The indices
  442. X * into an XView colormap segment always range from 0 to size-1, where
  443. X * size is the number of colors allocated in the colormap segment.
  444. X * These logical index values translate into actual indices into the
  445. X * colormap map as allocated by the X server. The WIN_X_COLOR_INDICES
  446. X * attribute returns the actual colormap indices. The indices are
  447. X * returned as an array of unsigned longs.
  448. X */
  449. Xmain(argc,argv)
  450. Xint     argc;
  451. Xchar    *argv[];
  452. X{
  453. X    Frame         frame;
  454. X    Canvas        canvas;
  455. X    Xv_cmsdata    cms_data;       
  456. X    unsigned char red[NUM_COLORS], green[NUM_COLORS], blue[NUM_COLORS];
  457. X    Display       *display;
  458. X    XGCValues     gc_val;
  459. X    XID           xid;
  460. X    Pixmap        xlogo;
  461. X    XGCValues     gcvalues;
  462. X    int           gcvaluemask;
  463. X    void          canvas_repaint_proc();
  464. X
  465. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  466. X
  467. X    /* initalize the cms data and set the required RGB values */
  468. X    initialize_cms_data(&cms_data, red, green, blue);
  469. X
  470. X    frame = (Frame)xv_create(XV_NULL, FRAME,
  471. X        FRAME_LABEL,    argv[0],
  472. X        XV_WIDTH,       448,
  473. X        XV_HEIGHT,      192,
  474. X        NULL);
  475. X
  476. X    canvas = (Canvas)xv_create(frame, CANVAS,
  477. X        CANVAS_X_PAINT_WINDOW,  TRUE,
  478. X        CANVAS_REPAINT_PROC,    canvas_repaint_proc,
  479. X        WIN_CMS_NAME,           "palette",
  480. X        WIN_CMS_DATA,           &cms_data,
  481. X        NULL);
  482. X
  483. X    /* Get the actual indices into the colormap */
  484. X    pixel_table = (int *)xv_get(canvas, WIN_X_COLOR_INDICES);
  485. X
  486. X    /* Get display and the XID of the canvas */
  487. X    display = (Display *)xv_get(canvas, XV_DISPLAY);
  488. X    xid = (XID)xv_get(canvas, XV_XID);
  489. X
  490. X    /* create the stipple xlogo */
  491. X    xlogo = XCreateBitmapFromData(display, xid, xlogo64_bits,
  492. X                      xlogo64_width, xlogo64_height);
  493. X
  494. X    /* setup gc for rendering logos to screen */
  495. X    gcvalues.function = GXcopy;
  496. X    gcvalues.stipple = xlogo;
  497. X    gcvalues.fill_style = FillStippled;
  498. X    gcvalues.graphics_exposures = False;
  499. X    gcvaluemask = GCFunction|GCStipple|GCFillStyle|GCGraphicsExposures;
  500. X
  501. X    /* create normal render gc for logo rendering */
  502. X    gc = XCreateGC(display, xid, gcvaluemask, &gcvalues);
  503. X
  504. X    /* Start event loop */
  505. X    xv_main_loop(frame);
  506. X}
  507. X
  508. X/*
  509. X * Draws onto the canvas using Xlib drawing functions.
  510. X * Draw the X logo into the window in three colors. In each case,
  511. X * change the GC's foreground color to the pixel value specified.
  512. X */
  513. Xvoid
  514. Xcanvas_repaint_proc(canvas, pw, display, xid, xrects)
  515. XCanvas      canvas;
  516. XXv_Window   pw;
  517. XDisplay     *display;
  518. XWindow      xid;
  519. XXv_xrectlist *xrects;
  520. X{
  521. X    XGCValues       gc_val;
  522. X    unsigned long   pixel_value;
  523. X
  524. X    /* draw the logos in red, green and blue */
  525. X    XSetForeground(display, gc, pixel_table[RED]);
  526. X    XFillRectangle(display, xid, gc, 64, 64,
  527. X        xlogo64_width, xlogo64_height);
  528. X
  529. X    XSetForeground(display, gc, pixel_table[GREEN]);
  530. X    XFillRectangle(display, xid, gc, 192, 64,
  531. X        xlogo64_width, xlogo64_height);
  532. X
  533. X    XSetForeground(display, gc, pixel_table[BLUE]);
  534. X    XFillRectangle(display, xid, gc, 320, 64,
  535. X        xlogo64_width, xlogo64_height);
  536. X}
  537. X
  538. X/*
  539. X * initialize_cms_data()
  540. X *    Initialize the colormap segment data and setup the RGB values.
  541. X */
  542. Xinitialize_cms_data(cms_data, red, green, blue)
  543. XXv_cmsdata      *cms_data;
  544. Xunsigned char   *red, *green, *blue;
  545. X{
  546. X    (red)[WHITE] = 255;  (green)[WHITE] = 255;  (blue)[WHITE] = 255;
  547. X    (red)[RED] = 255;    (green)[RED] = 0;      (blue)[RED] = 0;
  548. X    (red)[GREEN] = 0;    (green)[GREEN] = 255;  (blue)[GREEN] = 0;
  549. X    (red)[BLUE] = 0;     (green)[BLUE] = 0;     (blue)[BLUE] = 255;
  550. X
  551. X    cms_data->type = XV_STATIC_CMS;
  552. X    cms_data->size = 4;
  553. X    cms_data->rgb_count = 4;
  554. X    cms_data->index = 0;
  555. X    cms_data->red = red;
  556. X    cms_data->green = green;
  557. X    cms_data->blue = blue;
  558. X}
  559. END_OF_FILE
  560. if test 4703 -ne `wc -c <'xview.demos/color/color_logo.c'`; then
  561.     echo shar: \"'xview.demos/color/color_logo.c'\" unpacked with wrong size!
  562. fi
  563. # end of 'xview.demos/color/color_logo.c'
  564. fi
  565. if test -f 'xview.demos/menus/menu_dir.c' -a "${1}" != "-c" ; then 
  566.   echo shar: Will not clobber existing file \"'xview.demos/menus/menu_dir.c'\"
  567. else
  568. echo shar: Extracting \"'xview.demos/menus/menu_dir.c'\" \(5218 characters\)
  569. sed "s/^X//" >'xview.demos/menus/menu_dir.c' <<'END_OF_FILE'
  570. X/*
  571. X * menu_dir.c -
  572. X * Demonstrate the use of an XView menu in a canvas subwindow.
  573. X * A menu is brought up with the MENU mouse button and displays
  574. X * menu choices representing the files in the directory.  If a
  575. X * directory entry is found, a new pullright item is created with
  576. X * that subdir as the pullright menu's contents.  This implementation
  577. X * creates the entire directory tree initially.  Do not attempt to
  578. X * build a tree from /.  You will most likely run out of resources.
  579. X *
  580. X * argv[1] indicates which directory to start from.
  581. X */
  582. X#include <xview/xview.h>
  583. X#include <xview/canvas.h>
  584. X#include <sys/stat.h>
  585. X#include <sys/dir.h>
  586. X#include <X11/Xos.h>
  587. X#ifndef MAXPATHLEN
  588. X#include <sys/param.h> /* probably sun/BSD specific */
  589. X#endif /* MAXPATHLEN */
  590. X
  591. XFrame   frame;
  592. X
  593. X/*
  594. X * main -
  595. X *      Create a frame, canvas and menu.
  596. X *      A canvas receives input in its canvas_paint_window().
  597. X *      Its callback procedure calls menu_show().
  598. X */
  599. Xmain(argc,argv)
  600. Xint     argc;
  601. Xchar    *argv[];
  602. X{
  603. X    Canvas      canvas;
  604. X    extern void exit();
  605. X    void        my_event_proc();
  606. X    Menu        menu;
  607. X    Menu_item   mi, add_path_to_menu();
  608. X
  609. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  610. X
  611. X    frame = (Frame)xv_create(NULL, FRAME,
  612. X        FRAME_LABEL,            argv[1]? argv[1] : "cwd",
  613. X        FRAME_SHOW_FOOTER,      TRUE,
  614. X        NULL);
  615. X    canvas = (Canvas)xv_create(frame, CANVAS,
  616. X        FRAME_LABEL,    argv[0],
  617. X        XV_WIDTH,       400,
  618. X        XV_HEIGHT,      100,
  619. X        NULL);
  620. X
  621. X    mi = add_path_to_menu(argc > 1? argv[1] : ".");
  622. X    menu = (Menu)xv_get(mi, MENU_PULLRIGHT);
  623. X
  624. X    /* associate the menu to the canvas win for easy retrieval */
  625. X    xv_set(canvas_paint_window(canvas),
  626. X        WIN_CONSUME_EVENTS,     WIN_MOUSE_BUTTONS, NULL,
  627. X        WIN_EVENT_PROC,         my_event_proc,
  628. X        WIN_CLIENT_DATA,        menu,
  629. X        NULL);
  630. X
  631. X    window_fit(frame);
  632. X    window_main_loop(frame);
  633. X}
  634. X
  635. X/*
  636. X * my_action_proc - display the selected item in the frame footer.
  637. X */
  638. Xvoid
  639. Xmy_action_proc(menu, menu_item)
  640. XMenu    menu;
  641. XMenu_item       menu_item;
  642. X{
  643. X    xv_set(frame,
  644. X        FRAME_LEFT_FOOTER,      xv_get(menu_item, MENU_STRING),
  645. X        NULL);
  646. X}
  647. X
  648. X/*
  649. X * Call menu_show() to display menu on right mouse button push.
  650. X */
  651. Xvoid
  652. Xmy_event_proc(canvas, event)
  653. XCanvas  canvas;
  654. XEvent *event;
  655. X{
  656. X    if ((event_id(event) == MS_RIGHT) && event_is_down(event)) {
  657. X        Menu menu = (Menu)xv_get(canvas, WIN_CLIENT_DATA);
  658. X        menu_show(menu, canvas, event, NULL);
  659. X    }
  660. X}
  661. X
  662. X/*
  663. X * return an allocated char * that points to the last item in a path.
  664. X */
  665. Xchar *
  666. Xgetfilename(path)
  667. Xchar *path;
  668. X{
  669. X    char *p;
  670. X
  671. X    if (p = rindex(path, '/'))
  672. X        p++;
  673. X    else
  674. X        p = path;
  675. X    return strcpy(malloc(strlen(p)+1), p);
  676. X}
  677. X
  678. X/*
  679. X * The path passed in is scanned via readdir().  For each file in the
  680. X * path, a menu item is created and inserted into a new menu.  That
  681. X * new menu is made the PULLRIGHT_MENU of a newly created panel item
  682. X * for the path item originally passed it.  Since this routine is
  683. X * recursive, a new menu is created for each subdirectory under the
  684. X * original path.
  685. X */
  686. XMenu_item
  687. Xadd_path_to_menu(path)
  688. Xchar *path;
  689. X{
  690. X    DIR                 *dirp;
  691. X    struct direct       *dp;
  692. X    struct stat         s_buf;
  693. X    Menu_item           mi;
  694. X    Menu                next_menu;
  695. X    char                buf[MAXPATHLEN];
  696. X
  697. X    /* don't add a folder to the list if user can't read it */
  698. X    if (stat(path, &s_buf) == -1 || !(s_buf.st_mode & S_IREAD))
  699. X        return NULL;
  700. X    if (s_buf.st_mode & S_IFDIR) {
  701. X        int cnt = 0;
  702. X        if (!(dirp = opendir(path)))
  703. X            /* don't bother adding to list if we can't scan it */
  704. X            return NULL;
  705. X        next_menu = (Menu)xv_create(XV_NULL, MENU, NULL);
  706. X        while (dp = readdir(dirp))
  707. X            if (strcmp(dp->d_name, ".") && strcmp(dp->d_name, "..")) {
  708. X                (void) sprintf(buf, "%s/%s", path, dp->d_name);
  709. X                if (!(mi = add_path_to_menu(buf)))
  710. X                    /* unreadable file or dir - deactivate item */
  711. X                    mi = xv_create(XV_NULL, MENUITEM,
  712. X                        MENU_STRING,         getfilename(dp->d_name),
  713. X                        MENU_RELEASE,
  714. X                        MENU_RELEASE_IMAGE,
  715. X                        MENU_INACTIVE,       TRUE,
  716. X                        NULL);
  717. X                xv_set(next_menu, MENU_APPEND_ITEM, mi, NULL);
  718. X                cnt++;
  719. X            }
  720. X        closedir(dirp);
  721. X        mi = xv_create(XV_NULL, MENUITEM,
  722. X            MENU_STRING,        getfilename(path),
  723. X            MENU_RELEASE,
  724. X            MENU_RELEASE_IMAGE,
  725. X            MENU_NOTIFY_PROC,   my_action_proc,
  726. X            NULL);
  727. X        if (!cnt) {
  728. X            xv_destroy(next_menu);
  729. X            /* An empty or unsearchable directory - deactivate item */
  730. X            xv_set(mi, MENU_INACTIVE, TRUE, NULL);
  731. X        } else {
  732. X            xv_set(next_menu, MENU_TITLE_ITEM, getfilename(path), NULL);
  733. X            xv_set(mi, MENU_PULLRIGHT, next_menu, NULL);
  734. X        }
  735. X        return mi;
  736. X    }
  737. X    return (Menu_item)xv_create(NULL, MENUITEM,
  738. X        MENU_STRING,            getfilename(path),
  739. X        MENU_RELEASE,
  740. X        MENU_RELEASE_IMAGE,
  741. X        MENU_NOTIFY_PROC,       my_action_proc,
  742. X        NULL);
  743. X}
  744. END_OF_FILE
  745. if test 5218 -ne `wc -c <'xview.demos/menus/menu_dir.c'`; then
  746.     echo shar: \"'xview.demos/menus/menu_dir.c'\" unpacked with wrong size!
  747. fi
  748. # end of 'xview.demos/menus/menu_dir.c'
  749. fi
  750. if test -f 'xview.demos/misc/drag_n_drop.c' -a "${1}" != "-c" ; then 
  751.   echo shar: Will not clobber existing file \"'xview.demos/misc/drag_n_drop.c'\"
  752. else
  753. echo shar: Extracting \"'xview.demos/misc/drag_n_drop.c'\" \(4535 characters\)
  754. sed "s/^X//" >'xview.demos/misc/drag_n_drop.c' <<'END_OF_FILE'
  755. X/*
  756. X * drag_n_drop.c -- demonstrate how to handle drag and drop usage in
  757. X * OPEN LOOK. Create a base frame, canvas and text subwindow.  Install
  758. X * an event handler for the canvas to interpret drag-and-drop actions.
  759. X * The text subwindow is there for convenience, but you can drag and
  760. X * drop from anywhere on the screen.  The "file manager" application
  761. X * can be used to generate the ACTION_DRAG_LOAD event/action.  The user
  762. X * can select text and then "drag" the selection on top of the canvas
  763. X * window.  When this happens, the canvas' callback routine is called
  764. X * and the event_action(event) will be set accordingly.
  765. X */
  766. X#include <X11/Xlib.h>
  767. X#include <xview/xview.h>
  768. X#include <xview/canvas.h>
  769. X#include <xview/textsw.h>
  770. X#include <xview/seln.h>
  771. X
  772. Xmain(argc, argv)
  773. Xint     argc;
  774. Xchar    *argv[];
  775. X{
  776. X    Frame       frame;
  777. X    Canvas      canvas;
  778. X    void        event_handler();
  779. X
  780. X    xv_init(XV_INIT_ARGS, argc, argv, NULL);
  781. X
  782. X    frame = (Frame)xv_create(NULL, FRAME, NULL);
  783. X    canvas = (Canvas)xv_create(frame, CANVAS,
  784. X        XV_WIDTH,  300,
  785. X        XV_HEIGHT, 300,
  786. X        NULL);
  787. X    xv_set(canvas_paint_window(canvas),
  788. X        WIN_EVENT_PROC, event_handler,
  789. X        NULL);
  790. X    (void) xv_create(frame, TEXTSW,
  791. X        TEXTSW_CONTENTS,
  792. X            "This is a test of the emergency broadcasting system.",
  793. X        XV_HEIGHT, 300,
  794. X        XV_WIDTH,  300,
  795. X        NULL);
  796. X    window_fit(frame);
  797. X
  798. X    xv_main_loop(frame);
  799. X}
  800. X
  801. X/*
  802. X * handle the drag and drop actions.  Also handle the ACTION_PASTE
  803. X * event since it is very similar.  The action specifies how the
  804. X * event was generated.  In all drag-and-drop cases, the contents
  805. X * of the selection is held in the primary selection.  Use the
  806. X * selection service routines to extract the information.
  807. X */
  808. Xvoid
  809. Xevent_handler(window, event, arg)
  810. XXv_Window       window;
  811. XEvent           *event;
  812. XNotify_arg      arg;
  813. X{
  814. X    Display *dpy = (Display *)xv_get(window, XV_DISPLAY);
  815. X    char     msg[128];
  816. X
  817. X    /* not interested in action-up events */
  818. X    if (event_is_up(event))
  819. X        return;
  820. X    switch (event_action(event)) {
  821. X        case ACTION_PASTE:
  822. X        case ACTION_DRAG_LOAD:
  823. X        case ACTION_DRAG_COPY:
  824. X        case ACTION_DRAG_MOVE: {
  825. X            Seln_holder     holder;
  826. X            Seln_request   *result;
  827. X            Seln_rank       selection;
  828. X            char           *data;
  829. X            int             read_only;
  830. X
  831. X            /*
  832. X             * ACTION_PASTE is generated by hitting L8, or the "paste"
  833. X             * key on the left side of the keyboard.  This assumes you
  834. X             * have cut (L10) or copied (L6) a selection first.
  835. X             */
  836. X
  837. X            if (event_action(event) == ACTION_PASTE) {
  838. X                strcpy(msg, "paste from shelf: ");
  839. X                selection = SELN_SHELF;
  840. X            } else {
  841. X                sprintf(msg, "drag and drop (%s): ",
  842. X                    event_action(event) == ACTION_DRAG_MOVE ? "move" :
  843. X                    event_action(event) == ACTION_DRAG_LOAD ? "load" : "copy");
  844. X                selection = SELN_PRIMARY;
  845. X            }
  846. X            holder = seln_inquire(selection);
  847. X            result = seln_ask(&holder,
  848. X                SELN_REQ_IS_READONLY,    NULL,
  849. X                SELN_REQ_CONTENTS_ASCII, NULL,
  850. X                NULL);
  851. X            data = result->data;
  852. X            data += sizeof(Seln_attribute);
  853. X
  854. X            /* testing read-only is only important if the selection
  855. X             * came from a textsw.  If so, then we need to know if
  856. X             * it is read-only to head off a drag-move since we won't
  857. X             * be able to delete the selection from that window.
  858. X             * Note, there is no way to determine the type of the xview
  859. X             * object that is holding the selection! :-(
  860. X             */
  861. X
  862. X            if ((read_only = *(int *) data) == TRUE &&
  863. X                event_action(event) == ACTION_DRAG_MOVE)
  864. X                /* can't "move" text from a read-only window. use copy */
  865. X                return;
  866. X            data += sizeof(int) + sizeof(SELN_REQ_CONTENTS_ASCII);
  867. X            strcat(msg, data);
  868. X            if (event_action(event) == ACTION_DRAG_MOVE)
  869. X                /* ask holder to delete its selection for drag moves */
  870. X                seln_ask(&holder, SELN_REQ_DELETE, NULL, NULL);
  871. X            break;
  872. X        }
  873. X        default :
  874. X            /* we could go on and on with the above cases ... */
  875. X            return;
  876. X    }
  877. X    XClearWindow(dpy, xv_get(window, XV_XID));
  878. X    XDrawString(dpy, xv_get(window, XV_XID),
  879. X        DefaultGC(dpy, DefaultScreen(dpy)), 20, 20, msg, strlen(msg));
  880. X}
  881. END_OF_FILE
  882. if test 4535 -ne `wc -c <'xview.demos/misc/drag_n_drop.c'`; then
  883.     echo shar: \"'xview.demos/misc/drag_n_drop.c'\" unpacked with wrong size!
  884. fi
  885. # end of 'xview.demos/misc/drag_n_drop.c'
  886. fi
  887. if test -f 'xview.demos/notice/notice.c' -a "${1}" != "-c" ; then 
  888.   echo shar: Will not clobber existing file \"'xview.demos/notice/notice.c'\"
  889. else
  890. echo shar: Extracting \"'xview.demos/notice/notice.c'\" \(4345 characters\)
  891. sed "s/^X//" >'xview.demos/notice/notice.c' <<'END_OF_FILE'
  892. X/*
  893. X * notice.c --
  894. X * This application creates a frame, a panel, and 3 panel buttons.
  895. X * A message button, a Quit button (to exit the program) and a 
  896. X * dummy "commit" button.  Extra data is attached to the panel 
  897. X * items by the use of XV_KEY_DATA.  The callback routine for the 
  898. X * quit and Commit buttons is generalized enough that it can apply 
  899. X * to either button (or any arbitrary button) because it extracts 
  900. X * the expected "data" (via XV_KEY_DATA) from whatever panel 
  901. X * button might have called it.
  902. X */
  903. X#include <xview/xview.h>
  904. X#include <xview/panel.h>
  905. X#include <xview/notice.h>
  906. X
  907. X/*
  908. X * assign "data" to panel items using XV_KEY_DATA ... attach the 
  909. X * message panel item, a prompt string specific for the panel 
  910. X * item's notice_prompt, and a callback function if the user 
  911. X * chooses "yes".
  912. X */
  913. X#define MSG_ITEM        10 /* any arbitrary integer */
  914. X#define NOTICE_PROMPT   11
  915. X#define CALLBACK_FUNC   12
  916. X
  917. Xmain(argc,argv)
  918. Xint     argc;
  919. Xchar    *argv[];
  920. X{
  921. X    Frame       frame;
  922. X    Panel       panel;
  923. X    Panel_item  msg_item;
  924. X    Xv_opaque   my_notify_proc();
  925. X    extern int  exit();
  926. X
  927. X    /*
  928. X     * Initialize XView, and create frame, panel and buttons.
  929. X     */
  930. X    xv_init(XV_INIT_ARGS, argc, argv, NULL);
  931. X    frame = (Frame)xv_create(XV_NULL, FRAME,
  932. X        FRAME_LABEL,            argv[0],
  933. X        NULL);
  934. X    panel = (Panel)xv_create(frame, PANEL,
  935. X        PANEL_LAYOUT,           PANEL_VERTICAL,
  936. X        NULL);
  937. X    msg_item = (Panel_item)xv_create(panel, PANEL_MESSAGE, NULL);
  938. X    (void) xv_create(panel, PANEL_BUTTON,
  939. X        PANEL_LABEL_STRING,     "Quit",
  940. X        PANEL_NOTIFY_PROC,      my_notify_proc,
  941. X        XV_KEY_DATA,            MSG_ITEM,       msg_item,
  942. X        /* 
  943. X         * attach a prompt specific for this button used by 
  944. X         * notice_prompt() 
  945. X         */
  946. X        XV_KEY_DATA,            NOTICE_PROMPT,  "Really Quit?",
  947. X        /* 
  948. X         * a callback function to call if the user answers "yes" 
  949. X         * to prompt 
  950. X         */
  951. X        XV_KEY_DATA,            CALLBACK_FUNC,  exit,
  952. X        NULL);
  953. X    /*
  954. X     * now that the Quit button is under the message item, 
  955. X     * layout horizontally
  956. X     */
  957. X    xv_set(panel, PANEL_LAYOUT, PANEL_HORIZONTAL, NULL);
  958. X    (void) xv_create(panel, PANEL_BUTTON,
  959. X        PANEL_LABEL_STRING,     "Commit...",
  960. X        PANEL_NOTIFY_PROC,      my_notify_proc,
  961. X        XV_KEY_DATA,            MSG_ITEM,       msg_item,
  962. X        /* 
  963. X         * attach a prompt specific for this button used by 
  964. X         * notice_prompt() 
  965. X         */
  966. X        XV_KEY_DATA,            NOTICE_PROMPT,  "Update all changes?",
  967. X        /* 
  968. X         * Note there is no callback func here, but one could be 
  969. X         * written 
  970. X         */
  971. X        NULL);
  972. X
  973. X    window_fit(panel);
  974. X    window_fit(frame);
  975. X    xv_main_loop(frame);
  976. X}
  977. X
  978. X/*
  979. X * my_notify_proc()
  980. X * The notice appears as a result of notice_prompt().
  981. X * The "key data" associated with the panel item is extracted via 
  982. X * xv_get().  The resulting choice is displayed in the panel 
  983. X * message item.
  984. X */
  985. XXv_opaque
  986. Xmy_notify_proc(item, event)
  987. XPanel_item  item;
  988. XEvent      *event;
  989. X{
  990. X    int          result;
  991. X    int        (*func)();
  992. X    char        *prompt;
  993. X    Panel_item   msg_item;
  994. X    Panel        panel;
  995. X
  996. X    func = (int(*)())xv_get(item, XV_KEY_DATA, CALLBACK_FUNC);
  997. X    prompt = (char *)xv_get(item, XV_KEY_DATA, NOTICE_PROMPT);
  998. X    msg_item = (Panel_item)xv_get(item, XV_KEY_DATA, MSG_ITEM);
  999. X    panel = (Panel)xv_get(item, PANEL_PARENT_PANEL);
  1000. X    /*
  1001. X     *  Create the notice and get a response.
  1002. X     */
  1003. X    result = notice_prompt(panel, NULL,
  1004. X        NOTICE_MESSAGE_STRINGS,
  1005. X                prompt,
  1006. X                "Press YES to confirm",
  1007. X                "Press NO to cancel",
  1008. X                NULL,
  1009. X        NOTICE_BUTTON_YES,      "YES",
  1010. X        NOTICE_BUTTON_NO,       "NO",
  1011. X        NULL);
  1012. X
  1013. X    switch(result) {
  1014. X        case NOTICE_YES:
  1015. X            xv_set(msg_item, PANEL_LABEL_STRING, "Confirmed", NULL);
  1016. X            if (func)
  1017. X                (*func)();
  1018. X            break;
  1019. X        case NOTICE_NO:
  1020. X            xv_set(msg_item, PANEL_LABEL_STRING, "Cancelled", NULL);
  1021. X            break;
  1022. X        case NOTICE_FAILED:
  1023. X            xv_set(msg_item, PANEL_LABEL_STRING, "unable to pop-up", 
  1024. X              NULL);
  1025. X            break;
  1026. X        default:
  1027. X            xv_set(msg_item, PANEL_LABEL_STRING, "unknown choice", 
  1028. X              NULL);
  1029. X    }
  1030. X}
  1031. END_OF_FILE
  1032. if test 4345 -ne `wc -c <'xview.demos/notice/notice.c'`; then
  1033.     echo shar: \"'xview.demos/notice/notice.c'\" unpacked with wrong size!
  1034. fi
  1035. # end of 'xview.demos/notice/notice.c'
  1036. fi
  1037. if test -f 'xview.demos/notifier/ntfy_pipe.c' -a "${1}" != "-c" ; then 
  1038.   echo shar: Will not clobber existing file \"'xview.demos/notifier/ntfy_pipe.c'\"
  1039. else
  1040. echo shar: Extracting \"'xview.demos/notifier/ntfy_pipe.c'\" \(5313 characters\)
  1041. sed "s/^X//" >'xview.demos/notifier/ntfy_pipe.c' <<'END_OF_FILE'
  1042. X/*
  1043. X * notify_pipe.c -- fork and set up a pipe to read the IO from the
  1044. X * forked process.  The program to run is specified on the command
  1045. X * line.  The functions notify_set_input_func() and
  1046. X * notify_set_output_func() are used to install functions which read
  1047. X * and write to the process' stdin and stdout.
  1048. X * The program does not use any xview code -- just the notifier.
  1049. X */
  1050. X#include <stdio.h>
  1051. X#include <errno.h>
  1052. X#include <signal.h>
  1053. X#include <sys/time.h>
  1054. X#include <sys/types.h>
  1055. X#include <sys/wait.h>
  1056. X#include <sys/resource.h>
  1057. X#include <sys/ioctl.h>
  1058. X#include <xview/notify.h>
  1059. X
  1060. XNotify_client client1 = (Notify_client)10;
  1061. XNotify_client client2 = (Notify_client)11;
  1062. X
  1063. Xint pipe_io[2][2]; /* see diagram */
  1064. X/*
  1065. X *                 [0]                           [1]
  1066. X *    child reads:  |========= pipe_io[0] ========| <- parent writes
  1067. X *   pipe_io[0][0]                                     pipe_io[0][1]
  1068. X *
  1069. X *    parent reads: |========= pipe_io[1] ========| <- child writes
  1070. X *   pipe_io[1][0]                                     pipe_io[1][1]
  1071. X *
  1072. X * The parent process reads the output of the child process by reading
  1073. X * pipe_io[1][0] because the child is writing to pipe_io[1][1].
  1074. X * The child process gets its input from pipe_io[0][0] because the
  1075. X * parent writes to pipe_io[0][1].  Thus, one process is reading from
  1076. X * one end of the pipe while the other is writing at the other end.
  1077. X */
  1078. Xmain(argc, argv)
  1079. Xchar *argv[];
  1080. X{
  1081. X    Notify_value        read_it(), write_it(), sigchldcatcher();
  1082. X    int                 pid, i;
  1083. X    FILE                *fp;
  1084. X
  1085. X    if (!*++argv)
  1086. X        puts("specify a program [w/args]"), exit(1);
  1087. X
  1088. X    pipe(pipe_io[0]); /* set up input pipe */
  1089. X    pipe(pipe_io[1]); /* set up output pipe */
  1090. X    switch (pid = fork()) {
  1091. X        case -1:
  1092. X            close(pipe_io[0][0]);
  1093. X            close(pipe_io[0][1]);
  1094. X            close(pipe_io[1][0]);
  1095. X            close(pipe_io[1][1]);
  1096. X            perror("fork failed");
  1097. X            exit(1);
  1098. X        case  0: /* child */
  1099. X        /* redirect child's stdin (0), stdout (1) and stderr(2) */
  1100. X            dup2(pipe_io[0][0], 0);
  1101. X            dup2(pipe_io[1][1], 1);
  1102. X            dup2(pipe_io[1][1], 2);
  1103. X            for (i = getdtablesize(); i > 2; i--)
  1104. X                (void) close(i);
  1105. X            for (i = 0; i < NSIG; i++)
  1106. X                (void) signal(i, SIG_DFL);
  1107. X        execvp(*argv, argv);
  1108. X            if (errno == ENOENT)
  1109. X                printf("%s: command not found.\n", *argv);
  1110. X            else
  1111. X                perror(*argv);
  1112. X            perror("execvp");
  1113. X            _exit(-1);
  1114. X        default: /* parent */
  1115. X            close(pipe_io[0][0]); /* close unused portions of pipes */
  1116. X            close(pipe_io[1][1]);
  1117. X        }
  1118. X
  1119. X    /* when the process outputs data, read it */
  1120. X    notify_set_input_func(client1, read_it, pipe_io[1][0]);
  1121. X    notify_set_wait3_func(client1, sigchldcatcher, pid);
  1122. X
  1123. X    /* wait for user input -- then write data to pipe */
  1124. X    notify_set_input_func(client2, write_it, 0);
  1125. X    notify_set_wait3_func(client2, sigchldcatcher, pid);
  1126. X
  1127. X    notify_start();
  1128. X}
  1129. X
  1130. X/*
  1131. X * callback routine for when there is data on the parent's stdin to
  1132. X * read.  Read it and then write the data to the child process via
  1133. X * the pipe.
  1134. X */
  1135. XNotify_value
  1136. Xwrite_it(client, fd)
  1137. XNotify_client   client;
  1138. Xint fd;
  1139. X{
  1140. X    char buf[BUFSIZ];
  1141. X    int bytes, i;
  1142. X
  1143. X    /* only write to pipe (child's stdin) if user typed anything */
  1144. X    if (ioctl(fd, FIONREAD, &bytes) == -1 || bytes == 0) {
  1145. X        notify_set_input_func(client, NOTIFY_FUNC_NULL, pipe_io[0][1]);
  1146. X        close(pipe_io[0][1]);
  1147. X    } else
  1148. X        while (bytes > 0) {
  1149. X            if ((i = read(fd, buf, sizeof buf)) > 0) {
  1150. X                printf("[Sending %d bytes to pipe (fd=%d)]\n",
  1151. X                    i, pipe_io[0][1]);
  1152. X                write(pipe_io[0][1], buf, i);
  1153. X            } else if (i == -1)
  1154. X                break;
  1155. X            bytes -= i;
  1156. X        }
  1157. X    return NOTIFY_DONE;
  1158. X}
  1159. X
  1160. X/*
  1161. X * callback routine for when there is data on the child's stdout to
  1162. X * read.  Read, then write the data to stdout (owned by the parent).
  1163. X */
  1164. XNotify_value
  1165. Xread_it(client, fd)
  1166. XNotify_client   client;
  1167. Xregister int fd;
  1168. X{
  1169. X    char buf[BUFSIZ];
  1170. X    int bytes, i;
  1171. X
  1172. X    if (ioctl(fd, FIONREAD, &bytes) == 0)
  1173. X        while (bytes > 0) {
  1174. X            if ((i = read(fd, buf, sizeof buf)) > 0) {
  1175. X                printf("[Reading %d bytes from pipe (fd=%d)]\n",
  1176. X                    i, fd);
  1177. X                (void) write(1, buf, i);
  1178. X                bytes -= i;
  1179. X            }
  1180. X        }
  1181. X    return NOTIFY_DONE;
  1182. X}
  1183. X
  1184. X/*
  1185. X * handle the death of the child.  If the process dies, the child
  1186. X * dies and generates a SIGCHLD signal.  Capture it and disable the
  1187. X * functions that talk to the pipes.
  1188. X */
  1189. XNotify_value
  1190. Xsigchldcatcher(client, pid, status, rusage)
  1191. XNotify_client client; /* the client noted in main() */
  1192. Xint pid; /* the pid that died */
  1193. Xunion wait *status; /* the status of the process (unused here) */
  1194. Xstruct rusage *rusage; /* resources used by this process (unused) */
  1195. X{
  1196. X    if (WIFEXITED(*status)) {
  1197. X        printf("Process termined with status %d\n", status->w_retcode);
  1198. X        /* unregister input func with appropriate file descriptor */
  1199. X        notify_set_input_func(client, NOTIFY_FUNC_NULL,
  1200. X            (client == client1)? pipe_io[1][0] : 0);
  1201. X        return NOTIFY_DONE;
  1202. X    }
  1203. X    puts("SIGCHLD not handled");
  1204. X    return NOTIFY_IGNORED;
  1205. X}
  1206. END_OF_FILE
  1207. if test 5313 -ne `wc -c <'xview.demos/notifier/ntfy_pipe.c'`; then
  1208.     echo shar: \"'xview.demos/notifier/ntfy_pipe.c'\" unpacked with wrong size!
  1209. fi
  1210. # end of 'xview.demos/notifier/ntfy_pipe.c'
  1211. fi
  1212. if test -f 'xview.demos/panels/choices.c' -a "${1}" != "-c" ; then 
  1213.   echo shar: Will not clobber existing file \"'xview.demos/panels/choices.c'\"
  1214. else
  1215. echo shar: Extracting \"'xview.demos/panels/choices.c'\" \(3960 characters\)
  1216. sed "s/^X//" >'xview.demos/panels/choices.c' <<'END_OF_FILE'
  1217. X#include <xview/xview.h>
  1218. X#include <xview/panel.h>
  1219. X#include <xview/openmenu.h>
  1220. X
  1221. XPanel panel;
  1222. X
  1223. X#define gray_width 2
  1224. X#define gray_height 2
  1225. Xstatic char gray_bits[] = {
  1226. X    0x01, 0x02
  1227. X};
  1228. X#define gray1_width 16
  1229. X#define gray1_height 16
  1230. Xstatic char gray1_bits[] = {
  1231. X    0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
  1232. X    0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa,
  1233. X    0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa
  1234. X};
  1235. X#define gray3_width 16
  1236. X#define gray3_height 16
  1237. Xstatic char gray3_bits[] = {
  1238. X   0x11, 0x11, 0x00, 0x00, 0x44, 0x44, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00,
  1239. X   0x44, 0x44, 0x00, 0x00, 0x11, 0x11, 0x00, 0x00, 0x44, 0x44, 0x00, 0x00,
  1240. X   0x11, 0x11, 0x00, 0x00, 0x44, 0x44, 0x00, 0x00
  1241. X};
  1242. X
  1243. X
  1244. Xmain(argc, argv)
  1245. Xint argc;
  1246. Xchar *argv[];
  1247. X{
  1248. X    Frame    frame;
  1249. X    Menu    menu;
  1250. X    void    quit();
  1251. X    int        selected(), numeric_text(), toggle_selected();
  1252. X
  1253. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  1254. X
  1255. X    frame = xv_create(XV_NULL, FRAME,
  1256. X    XV_WIDTH,        450,
  1257. X    XV_HEIGHT,        250,
  1258. X    FRAME_SHOW_FOOTER,    TRUE,
  1259. X    NULL);
  1260. X    panel = xv_create(frame, PANEL, NULL);
  1261. X    xv_set(canvas_paint_window(panel), NULL);
  1262. X    xv_create(panel, PANEL_BUTTON,
  1263. X    PANEL_LABEL_STRING,     "Quit",
  1264. X    PANEL_NOTIFY_PROC,      quit,
  1265. X    PANEL_CLIENT_DATA,    frame,
  1266. X    NULL);
  1267. X
  1268. X    xv_create(panel, PANEL_CHOICE,
  1269. X    PANEL_CHOICE_STRINGS,    "One", "Two", "Three", "Four", NULL,
  1270. X    PANEL_NOTIFY_PROC,      selected,
  1271. X    PANEL_CLIENT_DATA,    frame,
  1272. X    NULL);
  1273. X    xv_create(panel, PANEL_CHOICE,
  1274. X    PANEL_DISPLAY_LEVEL,    PANEL_CURRENT,
  1275. X    PANEL_LABEL_STRING,     "Choices",
  1276. X    PANEL_CHOICE_STRINGS,    "One", "Two", "Three", "Four", NULL,
  1277. X    PANEL_NOTIFY_PROC,      selected,
  1278. X    PANEL_CLIENT_DATA,    frame,
  1279. X    NULL);
  1280. X    xv_create(panel, PANEL_CHOICE,
  1281. X    PANEL_LABEL_STRING,     "Choices",
  1282. X    PANEL_CHOICE_STRINGS,    "One", "Two", "Three", "Four", NULL,
  1283. X    PANEL_NOTIFY_PROC,      selected,
  1284. X    PANEL_CLIENT_DATA,    frame,
  1285. X    NULL);
  1286. X    xv_create(panel, PANEL_CHOICE,
  1287. X    PANEL_CHOOSE_ONE,    FALSE,
  1288. X    PANEL_LABEL_STRING,     "Choices",
  1289. X    PANEL_VALUE,        5, /* choices 1 and 3 */
  1290. X    PANEL_CHOICE_STRINGS,    "One", "Two", "Three", "Four", NULL,
  1291. X    PANEL_NOTIFY_PROC,      toggle_selected,
  1292. X    PANEL_CLIENT_DATA,    frame,
  1293. X    NULL);
  1294. X    xv_create(panel, PANEL_TOGGLE,
  1295. X    PANEL_FEEDBACK,        PANEL_MARKED,
  1296. X    PANEL_LABEL_STRING,     "Choices",
  1297. X    PANEL_VALUE,        5, /* choices 1 and 3 */
  1298. X    PANEL_CHOICE_STRINGS,    "One", "Two", "Three", "Four", NULL,
  1299. X    PANEL_NOTIFY_PROC,      toggle_selected,
  1300. X    PANEL_CLIENT_DATA,    frame,
  1301. X    NULL);
  1302. X    xv_create(panel, PANEL_NUMERIC_TEXT,
  1303. X    PANEL_LABEL_STRING,    "Numbers:",
  1304. X    PANEL_VALUE,        5,
  1305. X    PANEL_NOTIFY_PROC,    numeric_text,
  1306. X    PANEL_CLIENT_DATA,    frame,
  1307. X    NULL);
  1308. X    xv_main_loop(frame);
  1309. X}
  1310. X
  1311. Xint
  1312. Xtoggle_selected(item, value, event)
  1313. XPanel_item item;
  1314. Xunsigned value;
  1315. XEvent *event;
  1316. X{
  1317. X    char buf[32];
  1318. X    Frame frame = xv_get(item, PANEL_CLIENT_DATA);
  1319. X    int i;
  1320. X    buf[0] = 0;
  1321. X    if (event_id(event) == MS_LEFT) {
  1322. X    for (i = 0; value; i++, value >>= 1)
  1323. X        if (value & 1)
  1324. X        sprintf(buf+strlen(buf), "%s%c ",
  1325. X            xv_get(item, PANEL_CHOICE_STRING, i),
  1326. X            (value >> 1)? ',' : ' ');
  1327. X    xv_set(frame, FRAME_RIGHT_FOOTER, buf, NULL);
  1328. X    return XV_OK;
  1329. X    }
  1330. X    return XV_ERROR;
  1331. X}
  1332. X
  1333. Xint
  1334. Xselected(item, value, event)
  1335. XPanel_item item;
  1336. Xint value;
  1337. XEvent *event;
  1338. X{
  1339. X    char buf[32];
  1340. X    Frame frame = xv_get(item, PANEL_CLIENT_DATA);
  1341. X    if (event_id(event) == MS_LEFT) {
  1342. X    sprintf(buf, "\"%s\" selected",
  1343. X        xv_get(item, PANEL_CHOICE_STRING, panel_get_value(item)));
  1344. X    xv_set(frame, FRAME_RIGHT_FOOTER, buf, NULL);
  1345. X    return XV_OK;
  1346. X    }
  1347. X    return XV_ERROR;
  1348. X}
  1349. X
  1350. X
  1351. Xnumeric_text(item, value, event)
  1352. XPanel_item item;
  1353. Xint value;
  1354. XEvent *event;
  1355. X{
  1356. X    char buf[32];
  1357. X    Frame frame = xv_get(item, PANEL_CLIENT_DATA);
  1358. X
  1359. X    sprintf(buf, "\"%s\" set to %d",
  1360. X    xv_get(item, PANEL_LABEL_STRING), value);
  1361. X    xv_set(frame, FRAME_RIGHT_FOOTER, buf, NULL);
  1362. X    return PANEL_NEXT;
  1363. X}
  1364. X
  1365. Xvoid
  1366. Xquit(item, event)
  1367. XPanel_item item;
  1368. XEvent *event;
  1369. X{
  1370. X    Frame frame = xv_get(item, PANEL_CLIENT_DATA);
  1371. X    if (event_id(event) == MS_LEFT)
  1372. X    xv_destroy_safe(frame);
  1373. X}
  1374. END_OF_FILE
  1375. if test 3960 -ne `wc -c <'xview.demos/panels/choices.c'`; then
  1376.     echo shar: \"'xview.demos/panels/choices.c'\" unpacked with wrong size!
  1377. fi
  1378. # end of 'xview.demos/panels/choices.c'
  1379. fi
  1380. if test -f 'xview.demos/seln_svc/text_seln.c' -a "${1}" != "-c" ; then 
  1381.   echo shar: Will not clobber existing file \"'xview.demos/seln_svc/text_seln.c'\"
  1382. else
  1383. echo shar: Extracting \"'xview.demos/seln_svc/text_seln.c'\" \(5545 characters\)
  1384. sed "s/^X//" >'xview.demos/seln_svc/text_seln.c' <<'END_OF_FILE'
  1385. X/*
  1386. X * seln.c -- print the primary selection from the server.  If the 
  1387. X * selection is in a text subwindow, also print information about 
  1388. X * the line number(s) the selection spans and the indexes of 
  1389. X * the bytes within the textsw's buffer.
  1390. X */
  1391. X#include <stdio.h>
  1392. X#include <xview/xview.h>
  1393. X#include <xview/textsw.h>
  1394. X#include <xview/panel.h>
  1395. X#include <xview/server.h>
  1396. X#include <xview/seln.h>
  1397. X
  1398. XXv_Server       server;
  1399. XTextsw          textsw;
  1400. X
  1401. Xchar *get_selection();
  1402. X
  1403. Xmain(argc, argv)
  1404. Xchar *argv[];
  1405. X{
  1406. X    Frame       frame;
  1407. X    Panel       panel;
  1408. X    void        exit();
  1409. X    int        print_seln();
  1410. X
  1411. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  1412. X    frame = (Frame)xv_create(NULL, FRAME,
  1413. X    FRAME_LABEL,        argv[0],
  1414. X    NULL);
  1415. X    panel = (Panel)xv_create(frame, PANEL,
  1416. X    WIN_WIDTH,        WIN_EXTEND_TO_EDGE,
  1417. X    NULL);
  1418. X    (void) xv_create(panel, PANEL_BUTTON,
  1419. X        PANEL_LABEL_STRING,     "Quit",
  1420. X        PANEL_NOTIFY_PROC,      exit,
  1421. X        NULL);
  1422. X    (void) xv_create(panel, PANEL_BUTTON,
  1423. X        PANEL_LABEL_STRING,     "Get Selection",
  1424. X        PANEL_NOTIFY_PROC,      print_seln,
  1425. X        NULL);
  1426. X    window_fit(panel);
  1427. X
  1428. X    textsw = (Textsw)xv_create(frame, TEXTSW,
  1429. X        WIN_X,                  0,
  1430. X        WIN_BELOW,              panel,
  1431. X        WIN_ROWS,               10,
  1432. X        WIN_COLUMNS,            80,
  1433. X        TEXTSW_FILE_CONTENTS,   "/etc/passwd",
  1434. X        NULL);
  1435. X    window_fit(frame);
  1436. X
  1437. X    server = (Xv_Server)xv_get(xv_get(frame, XV_SCREEN), SCREEN_SERVER);
  1438. X
  1439. X    xv_main_loop(frame);
  1440. X}
  1441. X
  1442. Xint
  1443. Xprint_seln()
  1444. X{
  1445. X    char *text = get_selection();
  1446. X
  1447. X    if (text)
  1448. X        printf("---selection---\n%s\n---end seln---\n", text);
  1449. X
  1450. X    return XV_OK;
  1451. X}
  1452. X
  1453. X/*
  1454. X * Get the selection using selection_ask().  Note that if the 
  1455. X * selection is bigger than about 2K, the whole selection will 
  1456. X * not be gotten with one call, thus this method of getting the 
  1457. X * selection may not be sufficient.
  1458. X */
  1459. Xchar *
  1460. Xget_selection()
  1461. X{
  1462. X    long                sel_lin_num, lines_selected;
  1463. X    Textsw_index        first, last;
  1464. X    Seln_holder         holder;
  1465. X    Seln_result         result;
  1466. X    int                 len;
  1467. X    Seln_request        *response;
  1468. X    static char         selection_buf[BUFSIZ];
  1469. X    register char       *ptr;
  1470. X
  1471. X    /* get the holder of the primary selection */
  1472. X    holder = selection_inquire(server, SELN_PRIMARY);
  1473. X
  1474. X    /* If the selection occurs in the text subwindow, print lots of
  1475. X     * info about the selection.
  1476. X     */
  1477. X    if (seln_holder_same_client(&holder, textsw)) {
  1478. X        /* ask for information from the selection service */
  1479. X        response = selection_ask(server, &holder,
  1480. X            /* get index of the first and last chars in the textsw */
  1481. X            SELN_REQ_FIRST,             NULL,
  1482. X            SELN_REQ_LAST,              NULL,
  1483. X            /* get the actual selection bytes */
  1484. X            SELN_REQ_CONTENTS_ASCII,    NULL,
  1485. X            /* Now fool the textsw to think entire lines are selected */
  1486. X            SELN_REQ_FAKE_LEVEL,        SELN_LEVEL_LINE,
  1487. X            /* Get the line numbers of beginning and ending of the
  1488. X             * selection */
  1489. X            SELN_REQ_FIRST_UNIT,        NULL,
  1490. X            SELN_REQ_LAST_UNIT,         NULL,
  1491. X            NULL);
  1492. X        /* set the ptr to beginning of data -- SELN_REQ_FIRST */
  1493. X        ptr = response->data;
  1494. X        /* "first" is data succeeding SELN_REQ_FIRST -- skip attr */
  1495. X        first = *(Textsw_index *)(ptr += sizeof(SELN_REQ_FIRST));
  1496. X        ptr += sizeof(Textsw_index); /* skip over value of "first" */
  1497. X        /* "last" is data succeeding SELN_REQ_LAST -- skip attr */
  1498. X        last  = *(Textsw_index *)(ptr += sizeof(SELN_REQ_LAST));
  1499. X        ptr += sizeof(Textsw_index); /* skip over value of "last" */
  1500. X
  1501. X        /* advance pointer past SELN_REQ_CONTENTS_ASCII */
  1502. X        ptr += sizeof(SELN_REQ_CONTENTS_ASCII);
  1503. X        len = strlen(ptr); /* length of string in response */
  1504. X        (void) strcpy(selection_buf, ptr);
  1505. X        /*
  1506. X         * advance pointer past length of string.  If the string length
  1507. X     * isn't aligned to a 4-byte boundary, add the difference in
  1508. X     * bytes -- then advance pointer passed "value".
  1509. X         */
  1510. X        if (len % 4)
  1511. X            len = len + (4 - (len % 4));
  1512. X        ptr += len + sizeof(Seln_attribute); /* skip over "value" */
  1513. X
  1514. X        /* advance pointer past SELN_REQ_FAKE_LEVEL, SELN_LEVEL_LINE */
  1515. X        ptr += sizeof(SELN_REQ_FAKE_LEVEL) + sizeof(SELN_LEVEL_LINE);
  1516. X
  1517. X        sel_lin_num = *(long *)(ptr += sizeof(SELN_REQ_FIRST_UNIT));
  1518. X        ptr += sizeof(long);
  1519. X        lines_selected = *(long *)(ptr += sizeof(SELN_REQ_LAST_UNIT));
  1520. X        ptr += sizeof(long);
  1521. X
  1522. X        /* hack to workaround bug with SELN_REQ_LAST_UNIT always
  1523. X     * returning -1.  Count the lines explicitly in the selection.
  1524. X     */
  1525. X        if (lines_selected < 0) {
  1526. X            register char *p;
  1527. X            lines_selected++;
  1528. X            for (p = selection_buf; *p; p++)
  1529. X                if (*p == '\n')
  1530. X                    lines_selected++;
  1531. X        }
  1532. X        printf("index in textsw: %d-%d, line number(s) = %d-%d\n",
  1533. X            first+1, last+1, sel_lin_num+1,
  1534. X        sel_lin_num + lines_selected + 1);
  1535. X    } else {
  1536. X        /* the selection does not lie in our text subwindow */
  1537. X        response = selection_ask(server, &holder,
  1538. X            SELN_REQ_CONTENTS_ASCII, NULL,
  1539. X            NULL);
  1540. X        if (response->status != SELN_SUCCESS) {
  1541. X            printf("selection_ask() returns %d\n", response->status);
  1542. X            return NULL;
  1543. X        }
  1544. X        (void) strcpy(selection_buf,
  1545. X            response->data + sizeof(SELN_REQ_CONTENTS_ASCII));
  1546. X    }
  1547. X    return selection_buf;
  1548. X}
  1549. END_OF_FILE
  1550. if test 5545 -ne `wc -c <'xview.demos/seln_svc/text_seln.c'`; then
  1551.     echo shar: \"'xview.demos/seln_svc/text_seln.c'\" unpacked with wrong size!
  1552. fi
  1553. # end of 'xview.demos/seln_svc/text_seln.c'
  1554. fi
  1555. if test -f 'xview.demos/textsw/textsw.font.c' -a "${1}" != "-c" ; then 
  1556.   echo shar: Will not clobber existing file \"'xview.demos/textsw/textsw.font.c'\"
  1557. else
  1558. echo shar: Extracting \"'xview.demos/textsw/textsw.font.c'\" \(5472 characters\)
  1559. sed "s/^X//" >'xview.demos/textsw/textsw.font.c' <<'END_OF_FILE'
  1560. X/*
  1561. X * textsw.font.c --display a text subwindow and allow the user to edit
  1562. X * it.  Panel items allow the user to change the font (family, style and
  1563. X * size) of the textsw.
  1564. X */
  1565. X#include <xview/xview.h>
  1566. X#include <xview/panel.h>
  1567. X#include <xview/textsw.h>
  1568. X#include <xview/font.h>
  1569. X
  1570. XPanel_item      family_item, style_item, scale_item, name_item;
  1571. XTextsw          textsw;
  1572. X
  1573. Xmain(argc, argv)
  1574. Xint     argc;
  1575. Xchar    *argv[];
  1576. X{
  1577. X    Frame       frame;
  1578. X    Panel       panel;
  1579. X    Xv_Font     font;
  1580. X    void        change_font();
  1581. X    int         change_font_by_name();
  1582. X    extern void exit();
  1583. X
  1584. X    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  1585. X
  1586. X    frame = (Frame)xv_create(XV_NULL, FRAME,
  1587. X        FRAME_LABEL,            argv[0],
  1588. X        FRAME_SHOW_FOOTER,      TRUE,
  1589. X        NULL);
  1590. X
  1591. X    panel = (Panel)xv_create(frame, PANEL,
  1592. X        PANEL_LAYOUT,           PANEL_VERTICAL,
  1593. X        NULL);
  1594. X    (void) xv_create(panel, PANEL_BUTTON,
  1595. X        PANEL_LABEL_STRING,     "Quit",
  1596. X        PANEL_NOTIFY_PROC,      exit,
  1597. X        NULL);
  1598. X    family_item = (Panel_item)xv_create(panel, PANEL_CHOICE,
  1599. X        PANEL_LABEL_STRING,     "Family",
  1600. X        PANEL_LAYOUT,           PANEL_HORIZONTAL,
  1601. X        PANEL_DISPLAY_LEVEL,    PANEL_CURRENT,
  1602. X        PANEL_CHOICE_STRINGS,
  1603. X            FONT_FAMILY_DEFAULT, FONT_FAMILY_DEFAULT_FIXEDWIDTH,
  1604. X            FONT_FAMILY_LUCIDA, FONT_FAMILY_LUCIDA_FIXEDWIDTH,
  1605. X            FONT_FAMILY_ROMAN, FONT_FAMILY_SERIF, FONT_FAMILY_COUR,
  1606. X            FONT_FAMILY_CMR, FONT_FAMILY_GALLENT,
  1607. X            NULL,
  1608. X        PANEL_NOTIFY_PROC,      change_font,
  1609. X        NULL);
  1610. X    style_item = (Panel_item)xv_create(panel, PANEL_CHOICE,
  1611. X        PANEL_LABEL_STRING,     "Style",
  1612. X        PANEL_LAYOUT,           PANEL_HORIZONTAL,
  1613. X        PANEL_DISPLAY_LEVEL,    PANEL_CURRENT,
  1614. X        PANEL_CHOICE_STRINGS,
  1615. X            FONT_STYLE_DEFAULT, FONT_STYLE_NORMAL, FONT_STYLE_BOLD,
  1616. X            FONT_STYLE_ITALIC, FONT_STYLE_BOLD_ITALIC, NULL,
  1617. X        PANEL_NOTIFY_PROC,      change_font,
  1618. X        NULL);
  1619. X    scale_item = (Panel_item)xv_create(panel, PANEL_CHOICE,
  1620. X        PANEL_LABEL_STRING,     "Scale",
  1621. X        PANEL_LAYOUT,           PANEL_HORIZONTAL,
  1622. X        PANEL_DISPLAY_LEVEL,    PANEL_CURRENT,
  1623. X        PANEL_CHOICE_STRINGS,
  1624. X            "Small", "Medium", "Large", "X-Large", NULL,
  1625. X        PANEL_NOTIFY_PROC,      change_font,
  1626. X        NULL);
  1627. X    name_item = (Panel_item)xv_create(panel, PANEL_TEXT,
  1628. X        PANEL_LABEL_STRING,     "Font Name:",
  1629. X        PANEL_LAYOUT,           PANEL_HORIZONTAL,
  1630. X        PANEL_VALUE_DISPLAY_LENGTH, 20,
  1631. X        PANEL_NOTIFY_PROC,      change_font_by_name,
  1632. X        NULL);
  1633. X    window_fit(panel);
  1634. X
  1635. X    textsw = (Textsw)xv_create(frame, TEXTSW,
  1636. X        WIN_ROWS,               20,
  1637. X        WIN_COLUMNS,            80,
  1638. X        NULL);
  1639. X
  1640. X    window_fit(frame);
  1641. X
  1642. X    font = (Xv_Font)xv_get(frame, XV_FONT);
  1643. X    xv_set(textsw, WIN_FONT, font, NULL);
  1644. X    xv_set(frame, FRAME_LEFT_FOOTER, xv_get(font, FONT_NAME), NULL);
  1645. X
  1646. X    xv_main_loop(frame);
  1647. X}
  1648. X
  1649. Xvoid
  1650. Xchange_font(item, value, event)
  1651. XPanel_item   item;
  1652. XEvent       *event;
  1653. X{
  1654. X    static int  family, style, scale;
  1655. X    char        buf[128];
  1656. X    Frame       frame;
  1657. X    char        *family_name;
  1658. X    char        *style_name;
  1659. X    int         scale_value;
  1660. X    Xv_Font     font;
  1661. X
  1662. X    frame = (Frame)xv_get(xv_get(item, PANEL_PARENT_PANEL), XV_OWNER);
  1663. X    family_name = (char *) xv_get(family_item, PANEL_CHOICE_STRING,
  1664. X                    xv_get(family_item, PANEL_VALUE));
  1665. X    style_name = (char *) xv_get(style_item, PANEL_CHOICE_STRING,
  1666. X                    xv_get(style_item, PANEL_VALUE));
  1667. X    scale_value = (int) xv_get(scale_item, PANEL_VALUE);
  1668. X
  1669. X    xv_set(frame, FRAME_BUSY, TRUE, NULL);
  1670. X    font = (Xv_Font)xv_find(frame, FONT,
  1671. X        FONT_FAMILY,    family_name,
  1672. X        FONT_STYLE,     style_name,
  1673. X        /* scale_value happens to coincide with Window_rescale_state values */
  1674. X        FONT_SCALE,     scale_value,
  1675. X        NULL);
  1676. X    xv_set(frame, FRAME_BUSY, FALSE, NULL);
  1677. X
  1678. X    if (!font) {
  1679. X        if (item == family_item) {
  1680. X            sprintf(buf, "cannot load '%s'", family_name);
  1681. X            xv_set(family_item, PANEL_VALUE, family, NULL);
  1682. X        } else if (item == style_item) {
  1683. X            sprintf(buf, "cannot load '%s'", style_name);
  1684. X            xv_set(style_item, PANEL_VALUE, style, NULL);
  1685. X        } else {
  1686. X            sprintf(buf, "Not available in %s scale.",
  1687. X                xv_get(scale_item, PANEL_CHOICE_STRING, scale));
  1688. X            xv_set(scale_item, PANEL_VALUE, scale, NULL);
  1689. X        }
  1690. X        xv_set(frame, FRAME_RIGHT_FOOTER, buf, NULL);
  1691. X        return;
  1692. X    }
  1693. X    if (item == family_item)
  1694. X        family = value;
  1695. X    else if (item == style_item)
  1696. X        style = value;
  1697. X    else
  1698. X        scale = value;
  1699. X    xv_set(textsw, WIN_FONT, font, NULL);
  1700. X    sprintf(buf, "Current font: %s", xv_get(font, FONT_NAME));
  1701. X    xv_set(frame, FRAME_LEFT_FOOTER, buf, NULL);
  1702. X}
  1703. X
  1704. Xchange_font_by_name(item, event)
  1705. XPanel_item item;
  1706. XEvent *event;
  1707. X{
  1708. X    char buf[128];
  1709. X    char *name = (char *)xv_get(item, PANEL_VALUE);
  1710. X    Frame frame = (Frame)xv_get(xv_get(item, PANEL_PARENT_PANEL), XV_OWNER);
  1711. X    Xv_Font font = (Xv_Font)font = (Xv_Font)xv_find(frame, FONT,
  1712. X        FONT_NAME,      name,
  1713. X        NULL);
  1714. X
  1715. X    if (!font) {
  1716. X        sprintf(buf, "cannot load '%s'", name);
  1717. X        xv_set(frame, FRAME_RIGHT_FOOTER, buf, NULL);
  1718. X        return PANEL_NONE;
  1719. X    }
  1720. X    xv_set(textsw, WIN_FONT, font, NULL);
  1721. X    sprintf(buf, "Current font: %s", xv_get(font, FONT_NAME));
  1722. X    xv_set(frame, FRAME_LEFT_FOOTER, buf, NULL);
  1723. X    return PANEL_NONE;
  1724. X}
  1725. END_OF_FILE
  1726. if test 5472 -ne `wc -c <'xview.demos/textsw/textsw.font.c'`; then
  1727.     echo shar: \"'xview.demos/textsw/textsw.font.c'\" unpacked with wrong size!
  1728. fi
  1729. # end of 'xview.demos/textsw/textsw.font.c'
  1730. fi
  1731. echo shar: End of archive 3 \(of 6\).
  1732. cp /dev/null ark3isdone
  1733. MISSING=""
  1734. for I in 1 2 3 4 5 6 ; do
  1735.     if test ! -f ark${I}isdone ; then
  1736.     MISSING="${MISSING} ${I}"
  1737.     fi
  1738. done
  1739. if test "${MISSING}" = "" ; then
  1740.     echo You have unpacked all 6 archives.
  1741.     rm -f ark[1-9]isdone
  1742. else
  1743.     echo You still need to unpack the following archives:
  1744.     echo "        " ${MISSING}
  1745. fi
  1746. ##  End of shell archive.
  1747. exit 0
  1748.