home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume6 / vt100tool / part10 / vt100tool.c
Encoding:
C/C++ Source or Header  |  1986-11-30  |  24.9 KB  |  940 lines
  1. #ifndef lint
  2. static    char sccsid[] = "@(#)vt100tool.c 1.3 86/04/15 Copyr 1985 MITRE Corp.";
  3. #endif
  4.  
  5.  
  6. /*
  7.  * MITRE Corp. Bedford, MA
  8.  */
  9.  
  10. /*
  11.  *     Overview:    panelvttool: A shell subwindow emulating
  12.  *                        a vt100 terminal
  13.  *
  14.  */
  15.  
  16. /*
  17.  *      Author: Edward L. Lafferty
  18.  */
  19.  
  20. #include <suntool/tool_hs.h>
  21.  
  22. #include <suntool/ttysw.h>
  23. #include <stdio.h>
  24. #include <suntool/panel.h>
  25. #include "vconfig.h"
  26. #include <suntool/ttysw_impl.h>
  27. static short ic_image[258] = {
  28. #include "vshelltool.icon"
  29. };
  30.  
  31. #include <suntool/ttytlsw.h>
  32. #include <sunwindow/window_hs.h>
  33. #include <pixrect/pixrect_hs.h>
  34. #include <sundev/kbio.h>
  35. #include <sundev/kbd.h>
  36.  
  37.  
  38. extern int winheightp, winwidthp;
  39.  
  40. mpr_static(shellic_mpr, 64, 64, 1, ic_image);
  41.  
  42. static    struct icon icon = {64, 64, (struct pixrect *)NULL, 0, 0, 64, 64,
  43.         &shellic_mpr, 0, 0, 0, 0, (char *)NULL, (struct pixfont *)NULL,
  44.         ICON_BKGRDGRY};
  45.  
  46.  
  47.         static    sigwinchcatcher(), sigchldcatcher(),
  48.             sigtermcatcher(),setup_proc(), keyboard_proc(), button_proc();
  49.  
  50. static    struct tool *tool;
  51. struct toolsw *ttysw;
  52.  
  53. static  struct toolsw *setupsw, *arrowsw, *keypadsw, *normkeysw;
  54. static struct singlecolor scr_foreground = {100,100,100};
  55. static struct singlecolor scr_background = {0, 0, 0};
  56. static  caddr_t setup_button, keyboard_button;
  57.  
  58. static  caddr_t  local_choice, scroll_choice, screen_choice,
  59.                     cursor_choice,xon_choice,ansi_choice,wrap_choice,
  60.             newline_choice, size_choice, answerback_text, baud_rate,
  61.             label_choice;
  62. static  caddr_t  PF1_button, PF2_button, PF3_button, PF4_button, R1_button,
  63.          R2_button,R3_button,R4_button,R5_button,R6_button,
  64.          R7_button,R8_button,R9_button,R0_button,enter_button,
  65.          dot_button,comma_button,up_button,down_button,
  66.          left_button,right_button, minus_button;
  67.  
  68.  
  69. static  local_proc(), scroll_proc(), screen_proc(),
  70.             cursor_proc(),xon_proc(),ansi_proc(),wrap_proc(),
  71.             newline_proc(), size_proc(), baud_rate_proc(),
  72.             answer_proc(), label_proc(), norm_proc();
  73.  
  74. static    char *normalname = "VT100 Shell 2.0";
  75. static  Panel setup, arrow, keypad, normkey;
  76. static struct pixfont *font;
  77.  
  78. /* so we can set locally
  79.    and still inform the emulator*/
  80. extern int newline, wrap,cursor,vt52mode,big_screen,rev_screen, local;
  81. extern char  answer_message[];
  82.  
  83. /* defined in the emulator */
  84. extern char* translate_key();
  85. extern char main_font_directory[];
  86.  
  87. main(argc, argv)
  88.     int argc;
  89.     char **argv;
  90. {
  91.     char    *toolname = normalname;
  92.     char *tool_name = argv[0];
  93.     char **tool_attrs = NULL;
  94.  
  95.  
  96.     if(tool_parse_all(&argc,argv,&tool_attrs, tool_name) == -1)
  97.       {
  98.         tool_usage(tool_name);
  99.         exit(1);
  100.       }
  101.     /*
  102.      * Create tool window
  103.      */
  104.     tool = tool_make(WIN_NAME_STRIPE,TRUE,
  105.              WIN_ICON, &icon,
  106.              WIN_LABEL,normalname,
  107.              WIN_COLUMNS,83,
  108.              WIN_WIDTH, 680,
  109.              WIN_HEIGHT, 600,
  110.              0);
  111.  
  112.     tool_free_attribute_list(tool_attrs);
  113.     /*
  114.      * Create tty subwindow
  115.      * Libsuntool now has vt100 code instead of ansi
  116.      * Communicate with emulator via envirionment variable VTFONTS
  117.      */
  118.     setenv("VTFONTS", MAIN_FONT_DIR); 
  119.     ttysw = ttysw_createtoolsubwindow(tool, "ttysw", TOOL_SWEXTENDTOEDGE,
  120.         384);
  121.     if (ttysw == (struct toolsw *)NULL)
  122.         exit(1);
  123.     
  124.     setupsw = panel_create(tool, 0);
  125.     setup   = (Panel) setupsw->ts_data;
  126.  
  127.     strcpy(main_font_directory,MAIN_FONT_DIR);
  128.  
  129.     /* create the items for setup of vt100 screen */
  130.     setup_button = panel_create_item(setup,PANEL_BUTTON,
  131.  
  132.                      PANEL_NOTIFY_PROC,setup_proc,
  133.  
  134.                      PANEL_LABEL_IMAGE,
  135.                      panel_button_image(setup,
  136.                                 "Setup",
  137.                                 7,
  138.                                 NULL ),
  139.                      0);
  140.  
  141.     /* Set up the mouse driven keyboard */
  142.  
  143.     keyboard_button = panel_create_item(setup,PANEL_BUTTON,
  144.                         PANEL_NOTIFY_PROC,keyboard_proc,
  145.                         PANEL_LABEL_IMAGE,
  146.                         panel_button_image(setup,
  147.                                    "Keyboard",
  148.                                 8,
  149.                                 NULL ),
  150.                      0);
  151.     label_choice = panel_create_item(setup, PANEL_CHOICE,
  152.                      PANEL_SHOW_ITEM, TRUE,
  153.                      PANEL_LABEL_STRING, "Key Labels",
  154.                      PANEL_CHOICE_STRINGS,"Normal", "IBM",
  155.                                  "MRED","WD11",
  156.                      0,
  157.                      PANEL_NOTIFY_PROC, label_proc,
  158.                      PANEL_DISPLAY_LEVEL, PANEL_ALL,
  159.                      PANEL_FEEDBACK, PANEL_INVERTED,
  160.                      0);
  161.  
  162.  
  163.     local_choice = panel_create_item(setup,PANEL_CHOICE,
  164.         PANEL_SHOW_ITEM, FALSE,
  165.         PANEL_CHOICE_STRINGS,"Online","Local",0,
  166.         PANEL_NOTIFY_PROC, local_proc,
  167.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  168.                          0);
  169.  
  170.     scroll_choice = panel_create_item(setup,PANEL_CHOICE,
  171.         PANEL_SHOW_ITEM, FALSE,
  172.         PANEL_CHOICE_STRINGS,"Smooth","Jump",0,
  173.         PANEL_NOTIFY_PROC, scroll_proc,
  174.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  175.                          0);
  176.  
  177.     screen_choice = panel_create_item(setup,PANEL_CHOICE,
  178.         PANEL_SHOW_ITEM, FALSE,
  179.         PANEL_CHOICE_STRINGS,"Dark","Light",0,
  180.         PANEL_NOTIFY_PROC, screen_proc,
  181.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  182.                          0);
  183.  
  184.     cursor_choice = panel_create_item(setup,PANEL_CHOICE,
  185.         PANEL_SHOW_ITEM, FALSE,
  186.         PANEL_CHOICE_STRINGS,"Block","Under",0,
  187.         PANEL_NOTIFY_PROC, cursor_proc,
  188.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  189.                          0);
  190.  
  191.     xon_choice = panel_create_item(setup,PANEL_CHOICE,
  192.         PANEL_SHOW_ITEM, FALSE,
  193.         PANEL_CHOICE_STRINGS,"Xon","No-xon",0,
  194.         PANEL_NOTIFY_PROC, xon_proc,
  195.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  196.                          0);
  197.  
  198.     wrap_choice = panel_create_item(setup,PANEL_CHOICE,
  199.         PANEL_SHOW_ITEM, FALSE,
  200.         PANEL_CHOICE_STRINGS,"No Wrap","Wrap",0,
  201.         PANEL_NOTIFY_PROC, wrap_proc,
  202.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  203.                          0);
  204.  
  205.     newline_choice = panel_create_item(setup,PANEL_CHOICE,
  206.         PANEL_SHOW_ITEM, FALSE,
  207.         PANEL_CHOICE_STRINGS,"Newline","No Newline",0,
  208.         PANEL_NOTIFY_PROC, newline_proc,
  209.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  210.                          0);
  211.  
  212.     ansi_choice = panel_create_item(setup,PANEL_CHOICE,
  213.         PANEL_SHOW_ITEM, FALSE,
  214.         PANEL_CHOICE_STRINGS,"ANSI","VT-52",0,
  215.         PANEL_NOTIFY_PROC, ansi_proc,
  216.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  217.                          0);
  218.  
  219.     size_choice = panel_create_item(setup,PANEL_CHOICE,
  220.         PANEL_SHOW_ITEM, FALSE,
  221.         PANEL_CHOICE_STRINGS,"80 Col","132 Col",0,
  222.         PANEL_NOTIFY_PROC, size_proc,
  223.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  224.                          0);
  225.     answerback_text = panel_create_item(setup,PANEL_TEXT,
  226.         PANEL_SHOW_ITEM, FALSE,
  227.         PANEL_LABEL_STRING, "Answerback:",
  228.                 PANEL_NOTIFY_LEVEL, PANEL_NONE,
  229.         PANEL_VALUE, "",
  230.                 PANEL_VALUE_DISPLAY_LENGTH, 20,
  231.         0);
  232. /*    baud_rate = panel_create_item(setup, PANEL_CHOICE,
  233.             PANEL_LABEL_STRING, "Baud RATE",
  234.                 PANEL_CHOICE_STRINGS,"75","110","150","300","600","1200",
  235.                       "2400","4800","9600", "19200",0,
  236.                 PANEL_NOTIFY_PROC, baud_rate_proc,
  237.         PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
  238.                 PANEL_SHOW_ITEM,FALSE,
  239.                 0);
  240. */
  241.  
  242.     panel_set(setup,
  243.           PANEL_HEIGHT, PANEL_FIT_ITEMS,
  244.           PANEL_WIDTH, PANEL_CU(80),
  245.           0);
  246.  
  247.     /* Set up keypad */
  248.     /* Client data item is used by key process to determine which
  249.        key was moused. */
  250.  
  251.     keypadsw = panel_create(tool,
  252.                 PANEL_HEIGHT, PANEL_CU(27),
  253.                 PANEL_WIDTH, PANEL_CU(30),   
  254.                 PANEL_ITEM_X_GAP,1,
  255.                 PANEL_ITEM_Y_GAP,1,
  256.                 0);
  257.     keypad = (Panel) keypadsw->ts_data;
  258.  
  259.     PF1_button = panel_create_item(keypad, PANEL_BUTTON,
  260.                        PANEL_SHOW_ITEM, FALSE,
  261.                        PANEL_CLIENT_DATA, (int)11,
  262.                        PANEL_NOTIFY_PROC, button_proc,
  263.                        PANEL_LABEL_IMAGE,
  264.                        panel_button_image(keypad,
  265.                               "PF1",
  266.                               5,
  267.                               NULL),
  268.                        0);
  269.  
  270.     PF2_button = panel_create_item(keypad, PANEL_BUTTON,
  271.                        PANEL_SHOW_ITEM, FALSE,
  272.                        PANEL_CLIENT_DATA, (int)12,
  273.                        PANEL_NOTIFY_PROC, button_proc,
  274.                        PANEL_LABEL_IMAGE,
  275.                        panel_button_image(keypad,
  276.                               "PF2",
  277.                               5,
  278.                               NULL),
  279.                        0);
  280.     PF3_button = panel_create_item(keypad, PANEL_BUTTON,
  281.                        PANEL_SHOW_ITEM, FALSE,
  282.                        PANEL_CLIENT_DATA, (int)13,
  283.                     PANEL_NOTIFY_PROC, button_proc,
  284.                     PANEL_LABEL_IMAGE,
  285.                     panel_button_image(keypad,
  286.                                "PF3",
  287.                                5,
  288.                                NULL),
  289.                     0);
  290.  
  291.     PF4_button = panel_create_item(keypad, PANEL_BUTTON,
  292.                        PANEL_SHOW_ITEM, FALSE,
  293.                        PANEL_CLIENT_DATA, (int) 14,
  294.                     PANEL_NOTIFY_PROC, button_proc,
  295.                     PANEL_LABEL_IMAGE,
  296.                     panel_button_image(keypad,
  297.                                "PF4",
  298.                                5,
  299.                                NULL),
  300.                     0);
  301.  
  302.     R7_button = panel_create_item(keypad, PANEL_BUTTON,
  303.                       PANEL_SHOW_ITEM, FALSE,
  304.                       PANEL_CLIENT_DATA, 7,
  305.                     PANEL_NOTIFY_PROC, button_proc,
  306.                     PANEL_LABEL_IMAGE,
  307.                     panel_button_image(keypad,
  308.                                "7",
  309.                                5,
  310.                                NULL),
  311.                     0);
  312.  
  313.     R8_button = panel_create_item(keypad, PANEL_BUTTON,
  314.                       PANEL_SHOW_ITEM, FALSE,
  315.                       PANEL_CLIENT_DATA, 8,
  316.                     PANEL_NOTIFY_PROC, button_proc,
  317.                     PANEL_LABEL_IMAGE,
  318.                     panel_button_image(keypad,
  319.                                "8",
  320.                                5,
  321.                                NULL),
  322.                     0);
  323.  
  324.     R9_button = panel_create_item(keypad, PANEL_BUTTON,
  325.                       PANEL_SHOW_ITEM, FALSE,
  326.                       PANEL_CLIENT_DATA, 9,
  327.                     PANEL_NOTIFY_PROC, button_proc,
  328.                     PANEL_LABEL_IMAGE,
  329.                     panel_button_image(keypad,
  330.                                "9",
  331.                                5,
  332.                                NULL),
  333.                     0);
  334.  
  335.     minus_button = panel_create_item(keypad, PANEL_BUTTON,
  336.                      PANEL_SHOW_ITEM, FALSE,
  337.                      PANEL_CLIENT_DATA, 15,
  338.                     PANEL_NOTIFY_PROC, button_proc,
  339.                     PANEL_LABEL_IMAGE,
  340.                     panel_button_image(keypad,
  341.                                "-",
  342.                                5,
  343.                                NULL),
  344.                     0);
  345.  
  346.     R4_button = panel_create_item(keypad, PANEL_BUTTON,
  347.                       PANEL_SHOW_ITEM, FALSE,
  348.                       PANEL_CLIENT_DATA, 4,
  349.                     PANEL_NOTIFY_PROC, button_proc,
  350.                     PANEL_LABEL_IMAGE,
  351.                     panel_button_image(keypad,
  352.                                "4",
  353.                                5,
  354.                                NULL),
  355.                     0);
  356.  
  357.     R5_button = panel_create_item(keypad, PANEL_BUTTON,
  358.                       PANEL_SHOW_ITEM, FALSE,
  359.                       PANEL_CLIENT_DATA, 5,
  360.                     PANEL_NOTIFY_PROC, button_proc,
  361.                     PANEL_LABEL_IMAGE,
  362.                     panel_button_image(keypad,
  363.                                "5",
  364.                                5,
  365.                                NULL),
  366.                     0);
  367.  
  368.     R6_button = panel_create_item(keypad, PANEL_BUTTON,
  369.                       PANEL_SHOW_ITEM, FALSE,
  370.                       PANEL_CLIENT_DATA, 6,
  371.                     PANEL_NOTIFY_PROC, button_proc,
  372.                     PANEL_LABEL_IMAGE,
  373.                     panel_button_image(keypad,
  374.                                "6",
  375.                                5,
  376.                                NULL),
  377.                     0);
  378.  
  379.     comma_button = panel_create_item(keypad, PANEL_BUTTON,
  380.                      PANEL_SHOW_ITEM, FALSE,
  381.                      PANEL_CLIENT_DATA, 16,
  382.                     PANEL_NOTIFY_PROC, button_proc,
  383.                     PANEL_LABEL_IMAGE,
  384.                     panel_button_image(keypad,
  385.                                ",",
  386.                                5,
  387.                                NULL),
  388.                     0);
  389.  
  390.     R1_button = panel_create_item(keypad, PANEL_BUTTON,
  391.                       PANEL_SHOW_ITEM, FALSE,
  392.                       PANEL_CLIENT_DATA, 1,
  393.                     PANEL_NOTIFY_PROC, button_proc,
  394.                     PANEL_LABEL_IMAGE,
  395.                     panel_button_image(keypad,
  396.                                "1",
  397.                                5,
  398.                                NULL),
  399.                     0);
  400.  
  401.     R2_button = panel_create_item(keypad, PANEL_BUTTON,
  402.                       PANEL_SHOW_ITEM, FALSE,
  403.                       PANEL_CLIENT_DATA, 2,
  404.                     PANEL_NOTIFY_PROC, button_proc,
  405.                     PANEL_LABEL_IMAGE,
  406.                     panel_button_image(keypad,
  407.                                "2",
  408.                                5,
  409.                                NULL),
  410.                     0);
  411.  
  412.     R3_button = panel_create_item(keypad, PANEL_BUTTON,
  413.                       PANEL_SHOW_ITEM, FALSE,
  414.                       PANEL_CLIENT_DATA, 3,
  415.                     PANEL_NOTIFY_PROC, button_proc,
  416.                     PANEL_LABEL_IMAGE,
  417.                     panel_button_image(keypad,
  418.                                "3",
  419.                                5,
  420.                                NULL),
  421.                     0);
  422.     enter_button = panel_create_item(keypad, PANEL_BUTTON,
  423.                      PANEL_SHOW_ITEM, FALSE,
  424.                      PANEL_CLIENT_DATA, 17,
  425.                     PANEL_NOTIFY_PROC, button_proc,
  426.                     PANEL_LABEL_IMAGE,
  427.                     panel_button_image(keypad,
  428.                                "Enter",
  429.                                5,
  430.                                NULL),
  431.                     0);
  432.     R0_button = panel_create_item(keypad, PANEL_BUTTON,
  433.                       PANEL_SHOW_ITEM, FALSE,
  434.                       PANEL_CLIENT_DATA, 10,
  435.                     PANEL_NOTIFY_PROC, button_proc,
  436.                     PANEL_LABEL_IMAGE,
  437.                     panel_button_image(keypad,
  438.                                "0",
  439.                                13,
  440.                                NULL),
  441.                     0);
  442.  
  443.     dot_button = panel_create_item(keypad, PANEL_BUTTON,
  444.                        PANEL_SHOW_ITEM, FALSE,
  445.                        PANEL_CLIENT_DATA, 18,
  446.                     PANEL_NOTIFY_PROC, button_proc,
  447.                     PANEL_LABEL_IMAGE,
  448.                     panel_button_image(keypad,
  449.                                ".",
  450.                                5,
  451.                                NULL),
  452.                     0);
  453.  
  454.     arrowsw = panel_create(tool,  0);
  455.     arrow = (Panel) arrowsw->ts_data;
  456.  
  457.     up_button = panel_create_item(arrow, PANEL_BUTTON,
  458.                       PANEL_SHOW_ITEM, FALSE,
  459.                       PANEL_CLIENT_DATA, 19,
  460.                       PANEL_ITEM_X, PANEL_CU(8),
  461.                       PANEL_ITEM_Y, PANEL_CU(1),
  462.                       PANEL_NOTIFY_PROC, button_proc,
  463.                       PANEL_LABEL_IMAGE,
  464.                       panel_button_image(arrow,
  465.                              "^",
  466.                              5,
  467.                              NULL),
  468.                       0);
  469.     down_button = panel_create_item(arrow, PANEL_BUTTON,
  470.                     PANEL_SHOW_ITEM, FALSE,
  471.                     PANEL_CLIENT_DATA, 21,
  472.                     PANEL_ITEM_X, PANEL_CU(8),
  473.                     PANEL_ITEM_Y, PANEL_CU(3),
  474.                     PANEL_NOTIFY_PROC, button_proc,
  475.                     PANEL_LABEL_IMAGE,
  476.                     panel_button_image(arrow,
  477.                                "v",
  478.                                5,
  479.                                NULL),
  480.                     0);
  481.     left_button = panel_create_item(arrow, PANEL_BUTTON,
  482.                     PANEL_SHOW_ITEM, FALSE,
  483.                     PANEL_CLIENT_DATA, 22,
  484.                     PANEL_ITEM_X, PANEL_CU(2),
  485.                     PANEL_ITEM_Y, PANEL_CU(2),
  486.                     PANEL_NOTIFY_PROC, button_proc,
  487.                     PANEL_LABEL_IMAGE,
  488.                     panel_button_image(arrow,
  489.                                "<--",
  490.                                5,
  491.                                NULL),
  492.                     0);
  493.     right_button = panel_create_item(arrow, PANEL_BUTTON,
  494.                      PANEL_SHOW_ITEM, FALSE,
  495.                      PANEL_CLIENT_DATA, 20,
  496.                      PANEL_ITEM_X, PANEL_CU(15),
  497.                      PANEL_ITEM_Y, PANEL_CU(2),
  498.                     PANEL_NOTIFY_PROC, button_proc,
  499.                     PANEL_LABEL_IMAGE,
  500.                     panel_button_image(arrow,
  501.                                "-->",
  502.                                5,
  503.                                NULL),
  504.                     0);
  505.     panel_fit_height(arrow);
  506.  
  507.  
  508.  
  509.     label_setup();
  510.  
  511.  
  512.         /*
  513.      * Install tool in tree of windows
  514.      */
  515.     signal(SIGWINCH, sigwinchcatcher);
  516.     tool_install(tool);
  517.  
  518.     /*
  519.      * Start tty process
  520.      */
  521.     signal(SIGCHLD, sigchldcatcher);
  522.     signal(SIGTERM, sigtermcatcher);
  523.  
  524.     if (ttysw_fork(ttysw->ts_data, ++argv,
  525.         &ttysw->ts_io.tio_inputmask,
  526.         &ttysw->ts_io.tio_outputmask,
  527.         &ttysw->ts_io.tio_exceptmask) == -1) {
  528.         perror("vt100tool");
  529.         exit(1);
  530.     }
  531.     /*
  532.      * Handle input
  533.      */
  534.     tool_select(tool, 1 /* means wait for child process to die*/);
  535.     /*
  536.      * Cleanup
  537.      */
  538.     tool_destroy(tool);
  539.     exit(0);
  540. }
  541.  
  542. static
  543. sigchldcatcher()
  544. {
  545.     tool_sigchld(tool);
  546. }
  547.  
  548. static
  549. sigwinchcatcher()
  550. {
  551.     tool_sigwinch(tool);
  552. }
  553.  
  554. static
  555. sigtermcatcher()
  556. {
  557.     ttysw_done(ttysw->ts_data);
  558.     exit(0);
  559. }
  560. static int insetup = 0;
  561. static int inkeyboard = 0;
  562.  
  563. static
  564. setup_proc(item,event)
  565.      Panel_item item;
  566.      struct inputevent *event;
  567. {
  568.   if(insetup == 0)
  569.     {
  570.       panel_set(local_choice,PANEL_SHOW_ITEM,TRUE,0);
  571.       panel_set(scroll_choice,PANEL_SHOW_ITEM,TRUE,0);
  572.       panel_set(screen_choice,PANEL_SHOW_ITEM,TRUE,0);
  573.       panel_set(cursor_choice,PANEL_SHOW_ITEM,TRUE,0);
  574.       panel_set(xon_choice,PANEL_SHOW_ITEM,TRUE,0);
  575.       panel_set(ansi_choice,PANEL_SHOW_ITEM,TRUE,0);
  576.       panel_set(wrap_choice,PANEL_SHOW_ITEM,TRUE,0);
  577.       panel_set(newline_choice,PANEL_SHOW_ITEM,TRUE,0);
  578.       panel_set(answerback_text,PANEL_SHOW_ITEM,TRUE,0);
  579.       panel_set(baud_rate,PANEL_SHOW_ITEM,TRUE,0);
  580.       insetup = 1;
  581.     }
  582.   else
  583.     {
  584.       panel_set(local_choice,PANEL_SHOW_ITEM,FALSE,0);
  585.       panel_set(scroll_choice,PANEL_SHOW_ITEM,FALSE,0);
  586.       panel_set(screen_choice,PANEL_SHOW_ITEM,FALSE,0);
  587.       panel_set(cursor_choice,PANEL_SHOW_ITEM,FALSE,0);
  588.       panel_set(xon_choice,PANEL_SHOW_ITEM,FALSE,0);
  589.       panel_set(ansi_choice,PANEL_SHOW_ITEM,FALSE,0);
  590.       panel_set(wrap_choice,PANEL_SHOW_ITEM,FALSE,0);
  591.       panel_set(newline_choice,PANEL_SHOW_ITEM,FALSE,0);
  592.       panel_set(answerback_text,PANEL_SHOW_ITEM,FALSE,0);
  593.       panel_set(baud_rate,PANEL_SHOW_ITEM,FALSE,0);
  594.       strcpy(answer_message,(char*) panel_get_value(answerback_text));
  595.       insetup = 0;
  596.     }
  597. }
  598.  
  599. /* Toggle the appearance of the panel keyboard */
  600.  
  601. static
  602. keyboard_proc(item,event)
  603.      Panel_item item;
  604.      struct inputevent *event;
  605. {
  606.   if(inkeyboard == 0)
  607.     {
  608.       panel_set(PF1_button,PANEL_SHOW_ITEM,TRUE,0);
  609.       panel_set(PF2_button,PANEL_SHOW_ITEM,TRUE,0);
  610.       panel_set(PF3_button,PANEL_SHOW_ITEM,TRUE,0);
  611.       panel_set(PF4_button,PANEL_SHOW_ITEM,TRUE,0);
  612.       panel_set( R7_button,PANEL_SHOW_ITEM,TRUE,0);
  613.       panel_set( R8_button,PANEL_SHOW_ITEM,TRUE,0);
  614.       panel_set( R9_button,PANEL_SHOW_ITEM,TRUE,0);
  615.       panel_set( minus_button,PANEL_SHOW_ITEM,TRUE,0);
  616.       panel_set( R4_button,PANEL_SHOW_ITEM,TRUE,0);
  617.       panel_set( R5_button,PANEL_SHOW_ITEM,TRUE,0);
  618.       panel_set( R6_button,PANEL_SHOW_ITEM,TRUE,0);
  619.       panel_set( comma_button,PANEL_SHOW_ITEM,TRUE,0);
  620.       panel_set( R1_button,PANEL_SHOW_ITEM,TRUE,0);
  621.       panel_set( R2_button,PANEL_SHOW_ITEM,TRUE,0);
  622.       panel_set( R3_button,PANEL_SHOW_ITEM,TRUE,0);
  623.       panel_set( R0_button,PANEL_SHOW_ITEM,TRUE,0);
  624.       panel_set( dot_button,PANEL_SHOW_ITEM,TRUE,0);
  625.       panel_set( enter_button,PANEL_SHOW_ITEM,TRUE,0);
  626.       panel_set( up_button,PANEL_SHOW_ITEM,TRUE,0);
  627.       panel_set( down_button,PANEL_SHOW_ITEM,TRUE,0);
  628.       panel_set( right_button,PANEL_SHOW_ITEM,TRUE,0);
  629.       panel_set( left_button,PANEL_SHOW_ITEM,TRUE,0);
  630.       inkeyboard = 1;
  631.     }
  632.   else
  633.     {
  634.       panel_set(PF1_button,PANEL_SHOW_ITEM,FALSE,0);
  635.       panel_set(PF2_button,PANEL_SHOW_ITEM,FALSE,0);
  636.       panel_set(PF3_button,PANEL_SHOW_ITEM,FALSE,0);
  637.       panel_set(PF4_button,PANEL_SHOW_ITEM,FALSE,0);
  638.       panel_set( R7_button,PANEL_SHOW_ITEM,FALSE,0);
  639.       panel_set( R8_button,PANEL_SHOW_ITEM,FALSE,0);
  640.       panel_set( R9_button,PANEL_SHOW_ITEM,FALSE,0);
  641.       panel_set( minus_button,PANEL_SHOW_ITEM,FALSE,0);
  642.       panel_set( R4_button,PANEL_SHOW_ITEM,FALSE,0);
  643.       panel_set( R5_button,PANEL_SHOW_ITEM,FALSE,0);
  644.       panel_set( R6_button,PANEL_SHOW_ITEM,FALSE,0);
  645.       panel_set( comma_button,PANEL_SHOW_ITEM,FALSE,0);
  646.       panel_set( R1_button,PANEL_SHOW_ITEM,FALSE,0);
  647.       panel_set( R2_button,PANEL_SHOW_ITEM,FALSE,0);
  648.       panel_set( R3_button,PANEL_SHOW_ITEM,FALSE,0);
  649.       panel_set( R0_button,PANEL_SHOW_ITEM,FALSE,0);
  650.       panel_set( dot_button,PANEL_SHOW_ITEM,FALSE,0);
  651.       panel_set( enter_button,PANEL_SHOW_ITEM,FALSE,0);
  652.       panel_set( up_button,PANEL_SHOW_ITEM,FALSE,0);
  653.       panel_set( down_button,PANEL_SHOW_ITEM,FALSE,0);
  654.       panel_set( right_button,PANEL_SHOW_ITEM,FALSE,0);
  655.       panel_set( left_button,PANEL_SHOW_ITEM,FALSE,0);
  656.       inkeyboard = 0;
  657.     }
  658. }
  659.  
  660. /* What to do when a button is clicked */
  661. /* Since the meaning of the keys is a function of variables set in
  662.    the vt100 environment, this routine uses the translator which
  663.    is used to interpret real sun-2 keyboard actions: translate_key()
  664. */
  665.  
  666. static
  667. button_proc(item, event)
  668.      Panel_item item;
  669.      struct inputevent event;
  670. {
  671.   int button_pushed = 0;
  672.   extern  struct ttysubwindow  *_ttysw;
  673.   char * keystr;
  674.   button_pushed = (int) panel_get(item, PANEL_CLIENT_DATA);
  675.   switch (button_pushed)
  676.     {
  677.     case 11:
  678.       keystr = translate_key(KEY_RIGHT(1));
  679.       break;
  680.     case 12:
  681.       keystr = translate_key(KEY_RIGHT(2));
  682.       break;
  683.     case 13:
  684.       keystr = translate_key(KEY_RIGHT(3));
  685.       break;
  686.     case 7:
  687.       keystr = translate_key(KEY_RIGHT(4));
  688.       break;
  689.     case 8:
  690.       keystr = translate_key(KEY_RIGHT(5));
  691.       break;
  692.     case 9:
  693.       keystr = translate_key(KEY_RIGHT(6));
  694.       break;
  695.     case 4:
  696.       keystr = translate_key(KEY_RIGHT(7));
  697.       break;
  698.     case 5:
  699.       keystr = translate_key(KEY_RIGHT(8));
  700.       break;
  701.     case 6:
  702.       keystr = translate_key(KEY_RIGHT(9));
  703.       break;
  704.     case 1:
  705.       keystr = translate_key(KEY_RIGHT(10));
  706.       break;
  707.     case 2:
  708.       keystr = translate_key(KEY_RIGHT(11));
  709.       break;
  710.     case 3:
  711.       keystr = translate_key(KEY_RIGHT(12));
  712.       break;
  713.     case 10:
  714.       keystr = translate_key(KEY_RIGHT(13));
  715.       break;
  716.     case 18:
  717.       keystr = translate_key(KEY_RIGHT(14));
  718.       break;
  719.     case 17:
  720.       keystr = translate_key(KEY_RIGHT(15));
  721.       break;
  722.     case 19:
  723.       keystr = translate_key(KEY_TOP(3));
  724.       break;
  725.     case 21:
  726.       keystr = translate_key(KEY_TOP(4));
  727.       break;
  728.     case 22:
  729.       keystr = translate_key(KEY_TOP(5));
  730.       break;
  731.     case 20:
  732.       keystr = translate_key(KEY_TOP(6));
  733.       break;
  734.     case 14:
  735.       keystr = translate_key(KEY_TOP(7));
  736.       break;
  737.     case 15:
  738.       keystr = translate_key(KEY_TOP(8));
  739.       break;
  740.     case 16:
  741.       keystr = translate_key(KEY_TOP(9));
  742.       break;
  743.     default:
  744.       keystr = "";
  745.    }
  746.   if(local)
  747.     ttysw_output(_ttysw,keystr,strlen(keystr));
  748.   else
  749.     {
  750.       write(_ttysw->ttysw_pty,keystr, strlen(keystr));
  751.       /* Sorry about this hack */
  752.       /* We have to fake out the ttysw_input routine */
  753.       /* since it only queues up the input till the next */
  754.       /* real input event. We will actually write to the */
  755.       /* pty and not put the text into the input queue.*/
  756.     }
  757.  
  758. }
  759.  
  760.  
  761.  
  762. static
  763. local_proc(item,value,event)
  764.      Panel_item item;
  765.      int value;
  766.      struct inputevent event;
  767. {
  768.   local = value;
  769. }
  770.  
  771. static
  772. scroll_proc(item,value,event)
  773.      Panel_item item;
  774.      int value;
  775.      struct inputevent event;
  776. {
  777. }
  778. static
  779. screen_proc(item,value,event)
  780.      Panel_item item;
  781.      int value;
  782.      struct inputevent event;
  783. {
  784. /* Never could get this to work right!
  785.  
  786.   (value == 0) ? pw_whiteonblack(tool->tl_pixwin, 0, 1)
  787.     :pw_blackonwhite(tool->tl_pixwin,0 , 1);
  788.   (value == 0) ? rev_screen = 0:1;
  789.   pw_writebackground(tool->tl_pixwin, 0, 0,
  790.              winwidthp, winheightp, PIX_NOT(PIX_DST));
  791. */
  792. }
  793.  
  794.  
  795. static
  796. cursor_proc(item,value,event)
  797.      Panel_item item;
  798.      int value;
  799.      struct inputevent event;
  800. {
  801. }
  802. static
  803. xon_proc(item,value,event)
  804.      Panel_item item;
  805.      int value;
  806.      struct inputevent event;
  807. {
  808. }
  809. static
  810. ansi_proc(item,value,event)
  811.      Panel_item item;
  812.      int value;
  813.      struct inputevent event;
  814. {
  815. }
  816. static
  817. wrap_proc(item,value,event)
  818.      Panel_item item;
  819.      int value;
  820.      struct inputevent event;
  821. {
  822.   wrap = value;
  823. }
  824. static
  825. newline_proc(item,value,event)
  826.      Panel_item item;
  827.      int value;
  828.      struct inputevent event;
  829. {
  830.   newline = value;
  831. }
  832. static
  833. size_proc(item,value,event)
  834.      Panel_item item;
  835.      int value;
  836.      struct inputevent event;
  837. {
  838.   big_screen = value;
  839. }
  840.  
  841. static
  842. baud_rate_proc(item,value,event)
  843.      Panel_item item;
  844.      int value;
  845.      struct inputevent event;
  846. {
  847. }
  848.  
  849. static
  850. label_setup()
  851. {
  852.   keys[(int)panel_get(PF1_button,PANEL_CLIENT_DATA)].button_handle = PF1_button;
  853.   keys[(int)panel_get(PF2_button,PANEL_CLIENT_DATA)].button_handle = PF2_button;
  854.   keys[(int)panel_get(PF3_button,PANEL_CLIENT_DATA)].button_handle = PF3_button;
  855.   keys[(int)panel_get(PF4_button,PANEL_CLIENT_DATA)].button_handle = PF4_button;
  856.    keys[(int)panel_get(R7_button,PANEL_CLIENT_DATA)].button_handle = R7_button;
  857.    keys[(int)panel_get(R8_button,PANEL_CLIENT_DATA)].button_handle = R8_button;
  858.    keys[(int)panel_get(R9_button,PANEL_CLIENT_DATA)].button_handle = R9_button;
  859.    keys[(int)panel_get(minus_button,PANEL_CLIENT_DATA)].button_handle = minus_button;
  860.    keys[(int)panel_get(R4_button,PANEL_CLIENT_DATA)].button_handle = R4_button;
  861.    keys[(int)panel_get(R5_button,PANEL_CLIENT_DATA)].button_handle = R5_button;
  862.    keys[(int)panel_get(R6_button,PANEL_CLIENT_DATA)].button_handle = R6_button;
  863.    keys[(int)panel_get(comma_button,PANEL_CLIENT_DATA)].button_handle = comma_button;
  864.    keys[(int)panel_get(R1_button,PANEL_CLIENT_DATA)].button_handle = R1_button;
  865.    keys[(int)panel_get(R2_button,PANEL_CLIENT_DATA)].button_handle = R2_button;
  866.    keys[(int)panel_get(R3_button,PANEL_CLIENT_DATA)].button_handle = R3_button;
  867.    keys[(int)panel_get(R0_button,PANEL_CLIENT_DATA)].button_handle = R0_button;
  868.    keys[(int)panel_get(dot_button,PANEL_CLIENT_DATA)].button_handle = dot_button;
  869.    keys[(int)panel_get(enter_button,PANEL_CLIENT_DATA)].button_handle = enter_button;
  870.    keys[(int)panel_get(up_button,PANEL_CLIENT_DATA)].button_handle = up_button;
  871.    keys[(int)panel_get(down_button,PANEL_CLIENT_DATA)].button_handle = down_button;
  872.    keys[(int)panel_get(right_button,PANEL_CLIENT_DATA)].button_handle = right_button;
  873.    keys[(int)panel_get(left_button,PANEL_CLIENT_DATA)].button_handle = left_button;
  874. }
  875.  
  876. static
  877. label_proc(item,value,event)
  878.      Panel_item item;
  879.      int value;
  880.      struct inputevent event;
  881. {
  882.   int i;
  883.   switch (value){
  884.   case 0:
  885.     for(i = 1; i <= 22; i++)
  886.       panel_set(keys[i].button_handle,
  887.         PANEL_LABEL_IMAGE, panel_button_image(keypad,
  888.                                keys[i].norm_label,
  889.                                (i == 10)?13:5,
  890.                                NULL),
  891.         0);
  892.     break;
  893.   case 2:
  894.     for(i = 1; i <= 22; i++)
  895.       panel_set(keys[i].button_handle,
  896.         PANEL_LABEL_IMAGE,panel_button_image(keypad,
  897.                               keys[i].mred_label,
  898.                               (i == 10)?13:5,
  899.                               NULL),
  900.         0);
  901.     break;
  902.   case 1:
  903.     for(i = 1; i <= 22; i++)
  904.       panel_set(keys[i].button_handle,
  905.         PANEL_LABEL_IMAGE, panel_button_image(keypad,
  906.                                keys[i].ibm_label,
  907.                                (i ==10)?13 : 5,
  908.                                NULL),
  909.         0);
  910.     break;
  911.   case 3:
  912.     for(i = 1; i <= 22; i++)
  913.       panel_set(keys[i].button_handle,
  914.         PANEL_LABEL_IMAGE, panel_button_image(keypad,
  915.                                keys[i].wd11_label,
  916.                                (i ==10)?13 : 5,
  917.                                NULL),
  918.         0);
  919.     break;
  920.   case 4:
  921.     for(i = 1; i <= 22; i++)
  922.       panel_set(keys[i].button_handle,
  923.         PANEL_LABEL_IMAGE, panel_button_image(keypad,
  924.                                keys[i].emacs_label,
  925.                                (i ==10)?13 : 5,
  926.                                NULL),
  927.         0);
  928.     break;
  929.     
  930.   }
  931. }
  932.  
  933. static
  934. norm_proc(item, value,event)
  935.      Panel_item item;
  936.      int value;
  937.      struct inputevent event;
  938.  
  939. {}
  940.