home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / x / xyzext.zip / xyz / clients / xyztool / xyztool.c < prev   
C/C++ Source or Header  |  1992-07-18  |  24KB  |  919 lines
  1.  
  2.  
  3. #include <stdio.h>
  4. #include <string.h>
  5.  
  6. #include <X11/Xlib.h>
  7.  
  8. #include "xyzext.h"
  9.  
  10. #include <xview/xview.h>
  11. #include <xview/frame.h>
  12. #include <xview/panel.h>
  13. #include <xview/textsw.h>
  14. #include <xview/notice.h>
  15. #include <xview/notify.h>
  16.  
  17. char *display_env;
  18.  
  19. Display *xyz_display;
  20.  
  21. #define ENSURE_CONNECTION() \
  22.    if(xyz_display == NULL) { inform_no_xyz_display(panel); return; }
  23.  
  24. Bool polling;
  25. int poll_interval;
  26.  
  27. FILE *devnull;
  28.  
  29. Frame frame;
  30. Panel panel;
  31. Textsw textsw;
  32. Menu xyz_menu;
  33. Menu instrument_menu;
  34. Menu trace_menu;
  35. Panel_item pattern_text;
  36. Panel_item format_choice;
  37.  
  38. Frame pattern_frame;
  39. Panel pattern_panel;
  40.  
  41. Frame connect_frame;
  42. Panel connect_panel;
  43. Panel_item connect_text;
  44.  
  45. Frame state_frame;
  46. Panel state_panel;
  47. Panel_item display_text;
  48. Panel_item instrument_text;
  49. Panel_item tracing_text;
  50. Panel_item tracelevel_text;
  51. Panel_item status_text;
  52. Panel_item query_again_btn;
  53. Panel_item poll_interval_slider;
  54.  
  55. Frame change_tag_frame;
  56. Panel change_tag_panel;
  57. Panel_item change_tagname_text;
  58. Panel_item change_value_btn;
  59. Panel_item change_value_text;
  60. Panel_item change_tracelevel_btn;
  61. Panel_item change_tracelevel_slider;
  62.  
  63. Frame get_tag_frame;
  64. Panel get_tag_panel;
  65. Panel_item get_tagname_text;
  66. Panel_item get_value_text;
  67. Panel_item get_tracelevel_text;
  68.  
  69. Frame cur_tracelevel_frame;
  70. Panel cur_tracelevel_panel;
  71. Panel_item cur_tracelevel_slider;
  72.  
  73. void poll_now_proc();
  74.  
  75. XYZ_value *oldvalues = NULL;
  76. int oldnum = 0;
  77.  
  78. #define NUM_ALT_PATTERNS 4
  79.  
  80. void
  81. inform_no_xyz_display(item)
  82. Panel_item *item;
  83. {
  84.    (void) notice_prompt(item, NULL,
  85.       NOTICE_MESSAGE_STRINGS, "Your are not connected to XYZ display!", NULL,
  86.       NOTICE_BUTTON_YES, "Ok",
  87.       NULL);
  88. }
  89.  
  90. void
  91. more_patterns_proc(item, event)
  92. Panel_item item;
  93. Event *event;
  94. {
  95.    xv_set(pattern_frame, XV_SHOW, TRUE, FRAME_CMD_PUSHPIN_IN, TRUE, NULL);
  96. }
  97.  
  98. void
  99. connect_proc(item, event)
  100. Panel_item item;
  101. Event *event;
  102. {
  103.   if(xyz_display == NULL) {
  104.      xv_set(connect_frame, XV_SHOW, TRUE, FRAME_CMD_PUSHPIN_IN, TRUE, NULL);
  105.   } else {
  106.      (void) notice_prompt(panel, NULL,
  107.         NOTICE_MESSAGE_STRINGS, "Please disconnect first!", NULL,
  108.     NOTICE_BUTTON_YES, "Ok",
  109.     NULL);
  110.   }
  111. }
  112.  
  113. int
  114. xyz_io_error(Display *dpy)
  115. {
  116.    (void) notice_prompt(panel, NULL,
  117.       NOTICE_MESSAGE_STRINGS, "XYZ connection lost!", NULL,
  118.       NOTICE_BUTTON_YES, "Ok",
  119.       NULL);
  120.    xyz_display = NULL;
  121.    exit(1);
  122. }
  123.  
  124. void
  125. xyz_connect(display_name)
  126. char *display_name;
  127. {
  128.    xyz_display = XOpenDisplay(display_name);
  129.    if(xyz_display == NULL) {
  130.       (void) notice_prompt(connect_panel, NULL,
  131.      NOTICE_MESSAGE_STRINGS, "Could not connect to display!", NULL,
  132.      NOTICE_BUTTON_YES, "Ok",
  133.      NULL);
  134.    } else {
  135.       if(!XYZ_QueryExtension(xyz_display)) {
  136.      (void) notice_prompt(connect_panel, NULL,
  137.         NOTICE_MESSAGE_STRINGS, "Server not XYZ-capable!", NULL,
  138.         NOTICE_BUTTON_YES, "Ok",
  139.         NULL);
  140.          XCloseDisplay(xyz_display);
  141.      xyz_display = NULL;
  142.       } else {
  143.      oldnum = 0;
  144.      if(oldvalues != NULL) {
  145.         XYZ_FreeValueList(oldvalues);
  146.      }
  147.      XSynchronize(xyz_display, TRUE);
  148.      XSetIOErrorHandler(xyz_io_error);
  149.      xv_set(connect_frame, 
  150.         FRAME_CMD_PUSHPIN_IN, FALSE,
  151.         WIN_SHOW, FALSE,
  152.         NULL);
  153.         xv_set(display_text, PANEL_VALUE, display_name, NULL);
  154.       }
  155.    }
  156. }
  157.  
  158. Panel_setting;
  159. connect_text_proc(item, event)
  160. Panel_item item;
  161. Event *event;
  162. {
  163.    switch(event_action(event)) {
  164.    case '\n':
  165.    case '\r':
  166.       xyz_connect(xv_get(connect_text, PANEL_VALUE));
  167.       return PANEL_NONE;
  168.    default:
  169.       return panel_text_notify(item, event);
  170.    }
  171. }
  172.  
  173. void
  174. connect_btn_proc(item, event)
  175. Panel_item item;
  176. Event *event;
  177. {
  178.    xyz_connect(xv_get(connect_text, PANEL_VALUE));
  179. }
  180.  
  181. void
  182. disconnect_proc(item, event)
  183. Panel_item item;
  184. Event *event;
  185. {
  186.    if(xyz_display != NULL) {
  187.       XCloseDisplay(xyz_display);
  188.       xyz_display = NULL;
  189.       xv_set(state_frame, 
  190.      FRAME_CMD_PUSHPIN_IN, FALSE,
  191.      WIN_SHOW, FALSE,
  192.      NULL);
  193.       xv_set(change_tag_frame, 
  194.      FRAME_CMD_PUSHPIN_IN, FALSE,
  195.      WIN_SHOW, FALSE,
  196.      NULL);
  197.       xv_set(get_tag_frame, 
  198.      FRAME_CMD_PUSHPIN_IN, FALSE,
  199.      WIN_SHOW, FALSE,
  200.      NULL);
  201.       xv_set(cur_tracelevel_frame,
  202.      FRAME_CMD_PUSHPIN_IN, FALSE,
  203.      WIN_SHOW, FALSE,
  204.      NULL);
  205.    } else {
  206.       (void) notice_prompt(connect_panel, NULL,
  207.          NOTICE_MESSAGE_STRINGS, "Not connected to XYZ display!", NULL,
  208.      NOTICE_BUTTON_YES, "Ok",
  209.      NULL);
  210.    }
  211. }
  212.  
  213. void
  214. get_tag_proc(item, event)
  215. Panel_item item;
  216. Event *event;
  217. {
  218.    ENSURE_CONNECTION();
  219.    xv_set(get_tag_frame, XV_SHOW, TRUE, FRAME_CMD_PUSHPIN_IN, TRUE, NULL);
  220. }
  221.  
  222. void
  223. really_get_tag_proc(item, event)
  224. Panel_item item;
  225. Event *event;
  226. {
  227.    int value;
  228.    int tracelevel;
  229.    char *tagname_str;
  230.    char string[20];
  231.  
  232.    ENSURE_CONNECTION();
  233.    tagname_str = (char *) panel_get_value(get_tagname_text);
  234.    if(tagname_str == NULL || *tagname_str == '\0') {
  235.       (void) notice_prompt(change_tag_panel, NULL,
  236.          NOTICE_MESSAGE_STRINGS, "Please specify a tag name to get.", NULL,
  237.          NOTICE_BUTTON_YES, "Ok",
  238.          NULL);
  239.       return;
  240.    }
  241.    XYZ_GetTag(xyz_display, tagname_str, &value, &tracelevel);
  242.    sprintf(string, "%d", value);
  243.    xv_set(get_value_text, PANEL_VALUE, string, NULL);
  244.    sprintf(string, "%d", tracelevel);
  245.    xv_set(get_tracelevel_text, PANEL_VALUE, string, NULL);
  246. }
  247.  
  248. void
  249. update_state_panel(item, event)
  250. Panel_item item;
  251. Event *event;
  252. {
  253.    int instrument;
  254.    int tracing;
  255.    int tracelevel;
  256.    int status;
  257.    char *string;
  258.    char number[4];
  259.  
  260.    ENSURE_CONNECTION();
  261.    XYZ_QueryState(xyz_display, 
  262.       &instrument, &tracing, &tracelevel, &status);
  263.    if(instrument) {
  264.       string = "On";
  265.    } else {
  266.       string = "Off";
  267.    }
  268.    xv_set(instrument_text, PANEL_VALUE, string, NULL);
  269.    if(tracing) {
  270.       string = "On";
  271.    } else {
  272.       string = "Off";
  273.    }
  274.    xv_set(tracing_text, PANEL_VALUE, string, NULL);
  275.    sprintf(number, "%d", tracelevel);
  276.    xv_set(tracelevel_text, PANEL_VALUE, number, NULL);
  277.    if(status == XYZ_ERROR) {
  278.       string = "ERROR";
  279.    } else {
  280.       string = "No error";
  281.    }
  282.    xv_set(status_text, PANEL_VALUE, string, NULL);
  283. }
  284.  
  285. void
  286. display_state_proc(item, event)
  287. Panel_item item;
  288. Event *event;
  289. {
  290.    ENSURE_CONNECTION();
  291.    update_state_panel(item, event);
  292.    xv_set(state_frame, XV_SHOW, TRUE, FRAME_CMD_PUSHPIN_IN, TRUE, NULL);
  293. }
  294.  
  295. void
  296. full_reset_proc(item, event)
  297. Event *event;
  298. Panel_item item;
  299. {
  300.    ENSURE_CONNECTION();
  301.    XYZ_Instrument(xyz_display, FALSE);
  302.    XYZ_Trace(xyz_display, FALSE);
  303.    XYZ_SetCurTraceLevel(xyz_display, 255);
  304.    XYZ_ResetValues(xyz_display);
  305.    XYZ_ResetTraceLevels(xyz_display);
  306.    update_state_panel(item, event);
  307. }
  308.  
  309. void
  310. quit_proc(item, event)
  311. Event *event;
  312. Panel_item item;
  313. {
  314.    xv_destroy_safe(frame);
  315. }
  316.  
  317. void
  318. instrument_on_proc(item, event)
  319. Event *event;
  320. Panel_item item;
  321. {
  322.    ENSURE_CONNECTION();
  323.    XYZ_Instrument(xyz_display, TRUE);
  324.    update_state_panel(item, event);
  325. }
  326.  
  327. void
  328. instrument_off_proc(item, event)
  329. Event *event;
  330. Panel_item item;
  331. {
  332.    ENSURE_CONNECTION();
  333.    XYZ_Instrument(xyz_display, FALSE);
  334.    update_state_panel(item, event);
  335. }
  336.  
  337. void
  338. change_tag_proc(item, event)
  339. Panel_item item;
  340. Event *event;
  341. {
  342.    ENSURE_CONNECTION();
  343.    xv_set(change_tag_frame, XV_SHOW, TRUE, FRAME_CMD_PUSHPIN_IN, TRUE, NULL);
  344. }
  345.  
  346. void
  347. reset_values_proc(item, event)
  348. Event *event;
  349. Panel_item item;
  350. {
  351.    ENSURE_CONNECTION();
  352.    XYZ_ResetValues(xyz_display);
  353. }
  354.  
  355. void
  356. trace_on_proc(item, event)
  357. Event *event;
  358. Panel_item item;
  359. {
  360.    ENSURE_CONNECTION();
  361.    XYZ_Trace(xyz_display, TRUE);
  362.    update_state_panel(item, event);
  363. }
  364.  
  365. void
  366. trace_off_proc(item, event)
  367. Event *event;
  368. Panel_item item;
  369. {
  370.    ENSURE_CONNECTION();
  371.    XYZ_Trace(xyz_display, FALSE);
  372.    update_state_panel(item, event);
  373. }
  374.  
  375. void
  376. set_trace_level_proc(item, event)
  377. Event *event;
  378. Panel_item item;
  379. {
  380.    ENSURE_CONNECTION();
  381.    xv_set(cur_tracelevel_frame, 
  382.       XV_SHOW, TRUE, 
  383.       FRAME_CMD_PUSHPIN_IN, TRUE, 
  384.       NULL);
  385. }
  386.  
  387. void
  388. tag_trace_level_proc(item, event)
  389. Event *event;
  390. Panel_item item;
  391. {
  392.    ENSURE_CONNECTION();
  393. }
  394.  
  395. void
  396. reset_tag_trace_levels_proc(item, event)
  397. Event *event;
  398. Panel_item item;
  399. {
  400.    ENSURE_CONNECTION();
  401.    XYZ_ResetTraceLevels(xyz_display);
  402. }
  403.  
  404. void
  405. change_value_proc(item, event)
  406. Event *event;
  407. Panel_item item;
  408. {
  409.    char *tagname_str;
  410.    char *value_str;
  411.    int value;
  412.    int rc;
  413.  
  414.    ENSURE_CONNECTION();
  415.    tagname_str = (char *) panel_get_value(change_tagname_text);
  416.    if(tagname_str == NULL || *tagname_str == '\0') {
  417.       (void) notice_prompt(change_tag_panel, NULL,
  418.          NOTICE_MESSAGE_STRINGS,
  419.         "Please specify a tag name (or pattern) to change.", NULL,
  420.          NOTICE_BUTTON_YES, "Ok",
  421.          NULL);
  422.       return;
  423.    }
  424.    value_str = (char *) panel_get_value(change_value_text);
  425.    rc = sscanf(value_str, "%d", &value);
  426.    if(rc != 1) {
  427.       (void) notice_prompt(change_tag_panel, NULL,
  428.          NOTICE_MESSAGE_STRINGS, "Value not in right format", NULL,
  429.          NOTICE_BUTTON_YES, "Ok",
  430.          NULL);
  431.       return;
  432.    }
  433.    XYZ_SetValue(xyz_display, tagname_str, value);
  434. }
  435.  
  436. void
  437. change_tracelevel_proc(item, event)
  438. Panel_item item;
  439. Event *event;
  440. {
  441.    char *tagname_str;
  442.    int value;
  443.  
  444.    ENSURE_CONNECTION();
  445.    tagname_str = (char *) panel_get_value(change_tagname_text);
  446.    if(tagname_str == NULL || *tagname_str == '\0') {
  447.       (void) notice_prompt(item, NULL,
  448.          NOTICE_MESSAGE_STRINGS,
  449.         "Please specify a value (or pattern) to change.", NULL,
  450.          NOTICE_BUTTON_YES, "Ok",
  451.          NULL);
  452.       return;
  453.    }
  454.    value = (int) panel_get_value(change_tracelevel_slider);
  455.    XYZ_SetTraceLevel(xyz_display, tagname_str, value);
  456. }
  457.  
  458. void
  459. cur_tracelevel_proc(item, value, event)
  460. Panel_item item;
  461. int value;
  462. Event *event;
  463. {
  464.    ENSURE_CONNECTION();
  465.    XYZ_SetCurTraceLevel(xyz_display, value);
  466.    update_state_panel(item, event);
  467. }
  468.  
  469. int
  470. sort_values_helper(value1, value2)
  471. XYZ_value *value1;
  472. XYZ_value *value2;
  473. {
  474.    return strcmp(value1->tagname, value2->tagname);
  475. }
  476.  
  477. void
  478. sort_values(values, num)
  479. XYZ_value *values;
  480. int num;
  481. {
  482.    qsort(values, num, sizeof(XYZ_value), sort_values_helper);
  483. }
  484.  
  485. possibly_show_tag(tagname, value)
  486. char *tagname;
  487. int value;
  488. {
  489.    char value_str[20];
  490.  
  491.    if(value != 0) {
  492.       sprintf(value_str, "%10d  ", value);
  493.       textsw_insert(textsw, value_str, strlen(value_str));
  494.       textsw_insert(textsw, tagname, strlen(tagname));
  495.       textsw_insert(textsw, "\n", 1);
  496.    }
  497. }
  498.  
  499. void
  500. show_deltas(old, oldnum, new, newnum)
  501. XYZ_value *old;
  502. int oldnum;
  503. XYZ_value *new;
  504. int newnum;
  505. {
  506.    int i;
  507.    int j;
  508.    int rc;
  509.  
  510.    i = 0;
  511.    j = 0;
  512.    while(i < oldnum && j < newnum) {
  513.       rc = strcmp(old[i].tagname, new[j].tagname);
  514.       if(rc == 0) {
  515.      possibly_show_tag(new[j].tagname, new[j].value - old[i].value);
  516.      i++;
  517.      j++;
  518.       } else if(rc > 0) {
  519.      possibly_show_tag(new[j].tagname, new[j].value);
  520.          j++;
  521.       } else {
  522.      possibly_show_tag(old[i].tagname, -old[i].value);
  523.      i++;
  524.       }
  525.    }
  526.    if(i < oldnum) {
  527.       while(i < oldnum) {
  528.      possibly_show_tag(old[i].tagname, -old[i].value);
  529.      i++;
  530.       }
  531.    } else if(j < newnum) {
  532.       while(j < newnum) {
  533.      possibly_show_tag(new[j].tagname, new[j].value);
  534.      j++;
  535.       }
  536.    }
  537. }
  538.  
  539. Notify_value
  540. on_interval()
  541. {
  542.    poll_now_proc(NULL, NULL);
  543.    return NOTIFY_DONE;
  544. }
  545.  
  546. void
  547. cont_poll_proc(item, value, event)
  548. Panel_item item;
  549. int value;
  550. Event *event;
  551. {
  552.    struct itimerval timer;
  553.  
  554.    if(value) {
  555.       polling  = TRUE;
  556.       timer.it_value.tv_usec = 0;
  557.       timer.it_value.tv_sec = poll_interval;
  558.       timer.it_interval.tv_usec = 0;
  559.       timer.it_interval.tv_sec = poll_interval;
  560.       notify_set_itimer_func(frame, on_interval, ITIMER_REAL, &timer, NULL);
  561.    } else {
  562.       polling = FALSE;
  563.       notify_set_itimer_func(frame, NOTIFY_FUNC_NULL, ITIMER_REAL, NULL, NULL);
  564.    }
  565. }
  566.  
  567. void
  568. poll_interval_proc(item, value, event)
  569. Panel_item item;
  570. int value;
  571. Event *event;
  572. {
  573.    struct itimerval timer;
  574.  
  575.    poll_interval = value;
  576.    if(polling) {
  577.       timer.it_value.tv_usec = 0;
  578.       timer.it_value.tv_sec = poll_interval;
  579.       timer.it_interval.tv_usec = 0;
  580.       timer.it_interval.tv_sec = poll_interval;
  581.       notify_set_itimer_func(frame, on_interval, ITIMER_REAL, &timer, NULL);
  582.    }
  583. }
  584.  
  585. void
  586. poll_now_proc(item, event)
  587. Panel_item item;
  588. Event *event;
  589. {
  590.    char *pattern_strs[1 + NUM_ALT_PATTERNS];
  591.    char *pattern_str;
  592.    XYZ_value *values;
  593.    char value_str[20];
  594.    int total;
  595.    int returned;
  596.    int lens[1 + NUM_ALT_PATTERNS];
  597.    int len;
  598.    int pats;
  599.    int i;
  600.    Panel_item text;
  601.    static int count = 0;
  602.  
  603.    ENSURE_CONNECTION();
  604.  
  605.    pats = 0;
  606.    pattern_str = (char *) panel_get_value(pattern_text);
  607.    len = strlen(pattern_str);
  608.    if(len > 0) {
  609.       lens[pats] = len;
  610.       pattern_strs[pats] = pattern_str;
  611.       pats++;
  612.    }
  613.  
  614.    text = (Panel_item) xv_get(pattern_panel, PANEL_FIRST_ITEM);
  615.    for(i=0;i<NUM_ALT_PATTERNS;i++) {
  616.       pattern_str = (char *) panel_get_value(text);
  617.       len = strlen(pattern_str);
  618.       if(len > 0) {
  619.          lens[pats] = len;
  620.          pattern_strs[pats] = pattern_str;
  621.          pats++;
  622.       }
  623.       text = (Panel_item) xv_get(text, PANEL_NEXT_ITEM);
  624.    }
  625.  
  626.    if(pats == 0 && item != NULL) {
  627.       (void) notice_prompt(panel, NULL,
  628.          NOTICE_MESSAGE_STRINGS, "No patterns are specified.", NULL,
  629.          NOTICE_BUTTON_YES, "Ok",
  630.          NULL);
  631.       return;
  632.    }
  633.  
  634.    values = XYZ_ListValues(xyz_display, pats, pattern_strs, lens,
  635.       500, &total, &returned);
  636.    count++;
  637.    textsw_reset(textsw, 0, 0);
  638.    if(values == NULL) {
  639.       textsw_insert(textsw, "nothin\n", 7);
  640.       return;
  641.    }
  642.    sort_values(values, returned);
  643.    switch((int) panel_get_value(format_choice)) {
  644.    case 0:
  645.       show_deltas(NULL, 0, values, returned);
  646.       break;
  647.    case 1:
  648.       show_deltas(oldvalues, oldnum, values, returned);
  649.       break;
  650.    }
  651.    if(oldvalues != NULL) {
  652.       XYZ_FreeValueList(oldvalues);
  653.    }
  654.    oldvalues = values;
  655.    oldnum = returned;
  656. }
  657.  
  658. main(argc, argv)
  659. int argc;
  660. char *argv[];
  661. {
  662.    int i;
  663.    int width;
  664.  
  665.    xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);
  666.  
  667.    devnull = fopen("/dev/null", "w");
  668.  
  669.    frame = (Frame) xv_create(NULL, FRAME,
  670.       FRAME_LABEL, "XamineYourZerver Tool",
  671.       NULL);
  672.    panel = (Panel) xv_create(frame, PANEL, NULL);
  673.    xyz_menu = (Menu) xv_create(NULL, MENU,
  674.       MENU_ACTION_ITEM, "Connect ...", connect_proc,
  675.       MENU_ACTION_ITEM, "Disconnect", disconnect_proc,
  676.       MENU_ACTION_ITEM, "Change tag ...", change_tag_proc,
  677.       MENU_ACTION_ITEM, "Get tag ...", get_tag_proc,
  678.       MENU_ACTION_ITEM, "Display state", display_state_proc,
  679.       MENU_ACTION_ITEM, "Full reset", full_reset_proc,
  680.       MENU_ACTION_ITEM, "Quit", quit_proc,
  681.       NULL);
  682.    instrument_menu = (Menu) xv_create(NULL, MENU,
  683.       MENU_ACTION_ITEM, "Turn on", instrument_on_proc,
  684.       MENU_ACTION_ITEM, "Turn off", instrument_off_proc,
  685.       MENU_ACTION_ITEM, "Reset values", reset_values_proc,
  686.       NULL);
  687.    trace_menu = (Menu) xv_create(NULL, MENU,
  688.       MENU_ACTION_ITEM, "Turn on", trace_on_proc,
  689.       MENU_ACTION_ITEM, "Turn off", trace_off_proc,
  690.       MENU_ACTION_ITEM, "Set trace level ...", set_trace_level_proc,
  691.       MENU_ACTION_ITEM, "Reset tag trace levels", reset_tag_trace_levels_proc,
  692.       NULL);
  693.    (void) xv_create(panel, PANEL_BUTTON,
  694.       PANEL_LABEL_STRING, "XYZ",
  695.       PANEL_ITEM_MENU, xyz_menu,
  696.       NULL);
  697.    (void) xv_create(panel, PANEL_BUTTON,
  698.       PANEL_LABEL_STRING, "Instrument",
  699.       PANEL_ITEM_MENU, instrument_menu,
  700.       NULL);
  701.    (void) xv_create(panel, PANEL_BUTTON,
  702.       PANEL_LABEL_STRING, "Trace",
  703.       PANEL_ITEM_MENU, trace_menu,
  704.       NULL);
  705.    window_fit_height(panel);
  706.    panel = (Panel) xv_create(frame, PANEL, WIN_BELOW, panel, NULL);
  707.    polling = FALSE;
  708.    (void) xv_create(panel, PANEL_CHECK_BOX,
  709.       PANEL_LAYOUT, PANEL_HORIZONTAL,
  710.       PANEL_LABEL_STRING, "Continous poll?",
  711.       PANEL_CHOICE_STRINGS, "", NULL,
  712.       PANEL_NOTIFY_PROC, cont_poll_proc,
  713.       NULL);
  714.    xv_set(panel, PANEL_LAYOUT, PANEL_HORIZONTAL, NULL);
  715.    format_choice = (Panel_item) xv_create(panel, PANEL_CHOICE,
  716.       PANEL_LABEL_STRING, "Poll output format:",
  717.       PANEL_CHOICE_STRINGS, "Absolute", "Delta", NULL,
  718.       PANEL_VALUE, 0,
  719.       NULL);
  720.    (void) xv_create(panel, PANEL_BUTTON,
  721.       PANEL_LABEL_STRING, "Poll now",
  722.       PANEL_NOTIFY_PROC, poll_now_proc,
  723.       NULL);
  724.    poll_interval = 10;
  725.    poll_interval_slider = (Panel_item) xv_create(panel, PANEL_SLIDER,
  726.       PANEL_LABEL_STRING, "Poll interval (seconds): ",
  727.       PANEL_MIN_VALUE, 1,
  728.       PANEL_MAX_VALUE, 60,
  729.       PANEL_VALUE, poll_interval,
  730.       PANEL_NOTIFY_PROC, poll_interval_proc,
  731.       NULL);
  732.    xv_set(panel, PANEL_LAYOUT, PANEL_VERTICAL, NULL);
  733.    (void) xv_create(panel, PANEL_BUTTON,
  734.       PANEL_LABEL_STRING, "More patterns ...",
  735.       PANEL_NOTIFY_PROC, more_patterns_proc,
  736.       NULL);
  737.    pattern_text = (Panel_item) xv_create(panel, PANEL_TEXT,
  738.       PANEL_LABEL_STRING, "Pattern: ",
  739.       PANEL_VALUE, "*",
  740.       PANEL_VALUE_DISPLAY_LENGTH, 60,
  741.       PANEL_VALUE_STORED_LENGTH, 100,
  742.       NULL);
  743.    window_fit_height(panel);
  744.    textsw = xv_create(frame, TEXTSW,
  745.       WIN_BELOW, panel,
  746.       WIN_ROWS, 12,
  747.       TEXTSW_BROWSING, TRUE,
  748.       TEXTSW_AGAIN_RECORDING, FALSE,
  749.       TEXTSW_HISTORY_LIMIT, 0,
  750.       TEXTSW_IGNORE_LIMIT, TEXTSW_INFINITY,
  751.       TEXTSW_LINE_BREAK_ACTION, TEXTSW_CLIP,
  752.       TEXTSW_INSERT_MAKES_VISIBLE, TEXTSW_IF_AUTO_SCROLL,
  753.       TEXTSW_MEMORY_MAXIMUM, 0,
  754.       TEXTSW_LOWER_CONTEXT, -1,
  755.       TEXTSW_UPPER_CONTEXT, -1,
  756.       TEXTSW_AUTO_SCROLL_BY, 0,
  757.       NULL);
  758.    window_fit_height(textsw);
  759.    window_fit_height(frame);
  760.    connect_frame = (Frame) xv_create(frame, FRAME_CMD,
  761.       FRAME_LABEL, "XYZ Connect",
  762.       NULL);
  763.    connect_panel = (Panel) xv_get(connect_frame, FRAME_CMD_PANEL);
  764.    display_env = (char *) getenv("XYZDISPLAY");
  765.    if(display_env == NULL) {
  766.       display_env = (char *) getenv("DISPLAY");
  767.    }
  768.    connect_text = (Panel_item) xv_create(connect_panel, PANEL_TEXT,
  769.       PANEL_LABEL_STRING, "X11 XYZ-capable display: ",
  770.       PANEL_VALUE, display_env != NULL ? display_env : "",
  771.       PANEL_VALUE_DISPLAY_LENGTH, 25,
  772.       PANEL_NOTIFY_LEVEL, PANEL_SPECIFIED,
  773.       PANEL_NOTIFY_STRING, "\n\r",
  774.       PANEL_NOTIFY_PROC, connect_text_proc,
  775.       NULL);
  776.    (void) xv_create(connect_panel, PANEL_BUTTON,
  777.       PANEL_LABEL_STRING, "Connect",
  778.       PANEL_NOTIFY_PROC, connect_btn_proc,
  779.       NULL);
  780.    window_fit(connect_panel);
  781.    window_fit(connect_frame);
  782.    state_frame = (Frame) xv_create(frame, FRAME_CMD,
  783.       FRAME_LABEL, "XYZ Query State",
  784.       NULL);
  785.    state_panel = (Panel) xv_get(state_frame, FRAME_CMD_PANEL);
  786.        xv_set(state_panel, PANEL_LAYOUT, PANEL_VERTICAL, NULL);
  787.        display_text = (Panel_item) xv_create(state_panel, PANEL_TEXT,
  788.           PANEL_LABEL_STRING, "XYZ display:",
  789.           PANEL_VALUE_DISPLAY_LENGTH, 25,
  790.           PANEL_READ_ONLY, TRUE,
  791.           NULL);
  792.        instrument_text = (Panel_item) xv_create(state_panel, PANEL_TEXT, 
  793.           PANEL_LABEL_STRING, "Instrumentation:",
  794.           PANEL_VALUE_DISPLAY_LENGTH, 3,
  795.           PANEL_READ_ONLY, TRUE,
  796.           NULL);
  797.        tracing_text = (Panel_item) xv_create(state_panel, PANEL_TEXT, 
  798.           PANEL_LABEL_STRING, "Tracing:",
  799.           PANEL_VALUE_DISPLAY_LENGTH, 3,
  800.           PANEL_READ_ONLY, TRUE,
  801.           NULL);
  802.        tracelevel_text = (Panel_item) xv_create(state_panel, PANEL_TEXT, 
  803.           PANEL_LABEL_STRING, "Current trace level:",
  804.           PANEL_VALUE_DISPLAY_LENGTH, 3,
  805.           PANEL_READ_ONLY, TRUE,
  806.           NULL);
  807.        width = (int) xv_get(tracelevel_text, PANEL_LABEL_WIDTH);
  808.        xv_set(display_text, PANEL_LABEL_WIDTH, width, NULL);
  809.    xv_set(instrument_text, PANEL_LABEL_WIDTH, width, NULL);
  810.    xv_set(tracing_text, PANEL_LABEL_WIDTH, width, NULL);
  811.    status_text = (Panel_item) xv_create(state_panel, PANEL_TEXT, 
  812.       PANEL_LABEL_STRING, "Status:",
  813.       PANEL_READ_ONLY, TRUE,
  814.       PANEL_LABEL_WIDTH, width, 
  815.       PANEL_VALUE_DISPLAY_LENGTH, 8,
  816.       NULL);
  817.    query_again_btn = (Panel_item) xv_create(state_panel, PANEL_BUTTON,
  818.       PANEL_LABEL_STRING, "Query again",
  819.       PANEL_NOTIFY_PROC, update_state_panel,
  820.       NULL);
  821.    window_fit(state_panel);
  822.    window_fit(state_frame);
  823.    change_tag_frame = (Frame) xv_create(frame, FRAME_CMD,
  824.       FRAME_LABEL, "XYZ Change Tag",
  825.       NULL);
  826.    change_tag_panel = (Panel) xv_get(change_tag_frame, FRAME_CMD_PANEL);
  827.    change_tagname_text = (Panel_item) xv_create(change_tag_panel, PANEL_TEXT,
  828.       PANEL_LABEL_STRING, "Tagname:",
  829.       PANEL_VALUE_DISPLAY_LENGTH, 40,
  830.       PANEL_VALUE_STORED_LENGTH, 100,
  831.       NULL);
  832.    xv_set(change_tag_panel, PANEL_LAYOUT, PANEL_VERTICAL, NULL);
  833.    change_value_btn = (Panel_item) xv_create(change_tag_panel, PANEL_BUTTON,
  834.       PANEL_LABEL_STRING, "Set value",
  835.       PANEL_NOTIFY_PROC, change_value_proc,
  836.       NULL);
  837.    xv_set(change_tag_panel, PANEL_LAYOUT, PANEL_HORIZONTAL, NULL);
  838.    change_value_text = (Panel_item) xv_create(change_tag_panel, PANEL_TEXT,
  839.       PANEL_LABEL_STRING, "Value:",
  840.       PANEL_VALUE_DISPLAY_LENGTH, 8,
  841.       NULL);
  842.    xv_set(change_tag_panel, PANEL_LAYOUT, PANEL_VERTICAL, NULL);
  843.    change_tracelevel_btn = 
  844.       (Panel_item) xv_create(change_tag_panel, PANEL_BUTTON,
  845.       PANEL_LABEL_STRING, "Set trace level",
  846.       PANEL_NOTIFY_PROC, change_tracelevel_proc,
  847.       NULL);
  848.    xv_set(change_tag_panel, PANEL_LAYOUT, PANEL_HORIZONTAL, NULL);
  849.    change_tracelevel_slider = 
  850.       (Panel_item) xv_create(change_tag_panel, PANEL_SLIDER,
  851.       PANEL_LABEL_STRING, "Trace level:",
  852.       PANEL_MIN_VALUE, 0,
  853.       PANEL_MAX_VALUE, 255,
  854.       NULL);
  855.    window_fit(change_tag_panel);
  856.    window_fit(change_tag_frame);
  857.    get_tag_frame = (Frame) xv_create(frame, FRAME_CMD,
  858.       FRAME_LABEL, "XYZ Get Tag",
  859.       NULL);
  860.    get_tag_panel = (Panel) xv_get(get_tag_frame, FRAME_CMD_PANEL);
  861.    xv_set(get_tag_panel, PANEL_LAYOUT, PANEL_HORIZONTAL, NULL);
  862.    (void) xv_create(get_tag_panel, PANEL_BUTTON,
  863.       PANEL_LABEL_STRING, "Get tag",
  864.       PANEL_NOTIFY_PROC, really_get_tag_proc,
  865.       NULL);
  866.    get_tagname_text = (Panel_item) xv_create(get_tag_panel, PANEL_TEXT,
  867.       PANEL_LABEL_STRING, "Tag name:",
  868.       PANEL_VALUE_DISPLAY_LENGTH, 40,
  869.       PANEL_VALUE_STORED_LENGTH, 100,
  870.       NULL);
  871.    xv_set(get_tag_panel, PANEL_LAYOUT, PANEL_VERTICAL, NULL);
  872.    get_value_text = (Panel_item) xv_create(get_tag_panel, PANEL_TEXT,
  873.       PANEL_LABEL_STRING, "Value:",
  874.       PANEL_READ_ONLY, TRUE,
  875.       PANEL_VALUE_DISPLAY_LENGTH, 8,
  876.       NULL);
  877.    get_tracelevel_text = (Panel_item) xv_create(get_tag_panel, PANEL_TEXT,
  878.       PANEL_LABEL_STRING, "Trace level:",
  879.       PANEL_READ_ONLY, TRUE,
  880.       PANEL_VALUE_DISPLAY_LENGTH, 8,
  881.       NULL);
  882.    window_fit(get_tag_panel);
  883.    window_fit(get_tag_frame);
  884.    cur_tracelevel_frame = (Frame) xv_create(frame, FRAME_CMD,
  885.       FRAME_LABEL, "XYZ Set Current Trace Level",
  886.       NULL);
  887.    cur_tracelevel_panel = (Panel) xv_get(cur_tracelevel_frame, FRAME_CMD_PANEL);
  888.    cur_tracelevel_slider = 
  889.       (Panel_item) xv_create(cur_tracelevel_panel, PANEL_SLIDER,
  890.       PANEL_LABEL_STRING, "Current trace level:",
  891.       PANEL_MIN_VALUE, 0,
  892.       PANEL_MAX_VALUE, 255,
  893.       PANEL_NOTIFY_PROC, cur_tracelevel_proc,
  894.       NULL);
  895.    window_fit(cur_tracelevel_panel);
  896.    window_fit(cur_tracelevel_frame);
  897.    pattern_frame = (Frame) xv_create(frame, FRAME_CMD,
  898.       FRAME_LABEL, "More Patterns",
  899.       NULL);
  900.    pattern_panel = (Panel) xv_get(pattern_frame, FRAME_CMD_PANEL);
  901.    for(i=0;i<NUM_ALT_PATTERNS;i++) {
  902.       char label[40];
  903.  
  904.       (void) sprintf(label, "Pattern %d:", i+2);
  905.       (void) xv_create(pattern_panel, PANEL_TEXT,
  906.          PANEL_LABEL_STRING, label,
  907.      PANEL_VALUE_DISPLAY_LENGTH, 60,
  908.      PANEL_VALUE_STORED_LENGTH, 100,
  909.          NULL);
  910.    }
  911.    window_fit(pattern_panel);
  912.    window_fit(pattern_frame);
  913.    xv_main_loop(frame);
  914.    if(xyz_display != NULL) {
  915.       XCloseDisplay(xyz_display);
  916.    }
  917.    exit(0);
  918. }
  919.