home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / cellsim / v2_5 / src / cellscr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-04  |  73.5 KB  |  2,885 lines
  1. /*****
  2.  *
  3.  * File: cellscr.c
  4.  *
  5.  * Cellsim, cellular automata simulator
  6.  *
  7.  * SunView-specific routines
  8.  *
  9.  *****/
  10.  
  11.  
  12. #include "cellscr.h"
  13.  
  14. /* Note: Original black & white code was supplied by Carl Uhrik, and
  15.  * subsequently modified by D. Hiebeler for better speed and
  16.  * functionality.
  17.  */
  18.  
  19. /*
  20.  *
  21.  * Cellsim copyright 1989, 1990 by Chris Langton and Dave Hiebeler
  22.  * (cgl@lanl.gov, hiebeler@heretic.lanl.gov)
  23.  *
  24.  * This package may be freely distributed, as long as you don't:
  25.  * - remove this notice
  26.  * - try to make money by doing so
  27.  * - prevent others from copying it freely
  28.  * - distribute modified versions without clearly documenting your changes
  29.  *   and notifying us
  30.  *
  31.  * Please contact either of the authors listed above if you have questions
  32.  * or feel an exception to any of the above restrictions is in order.
  33.  *
  34.  * If you make changes to the code, or have suggestions for changes,
  35.  * let us know!  If we use your suggestion, you will receive full credit
  36.  * of course.
  37.  */
  38.  
  39. /*****
  40.  * Cellsim history:
  41.  *
  42.  * Cellsim was originally written on Apollo workstations by Chris Langton.
  43.  *
  44.  * Sun versions:
  45.  *
  46.  * - version 1.0
  47.  *   by C. Ferenbaugh and C. Langton
  48.  *   released 09/02/88
  49.  *
  50.  * - version 1.5
  51.  *   by Dave Hiebeler and C. Langton  May - June 1989
  52.  *   released 07/03/89
  53.  *
  54.  * - version 2.0
  55.  *   by Dave Hiebeler and C. Langton  July - August 1989
  56.  *   never officially released (unofficially released 09/08/89)
  57.  *
  58.  * - version 2.5
  59.  *   by Dave Hiebeler and C. Langton  September '89 - February 1990
  60.  *   released 02/26/90
  61.  *****/
  62.  
  63.  
  64.     
  65.     
  66. /****************************** initialization ******************************/
  67.  
  68. remove_frame_args(argc, argv)
  69.     int    *argc;
  70.     char  **argv;
  71. {
  72.     frame = window_create(NULL, FRAME, FRAME_LABEL, "Cellsim 2.5",
  73.               FRAME_ARGC_PTR_ARGV, argc, argv, 0);
  74.     if (frame == NULL) {
  75.     perror("cellsim");
  76.     exit(1);
  77.     }
  78. }
  79.  
  80.  
  81. init_scr()
  82. {
  83.     char   *str;
  84.     int     i, button_vsize=20;
  85.     /* Panel_item item; */
  86.     Menu tmp_menu;
  87.     Pixfont *screenr11, *screenr12;
  88.     char CM_port_str[20];
  89.  
  90.     screenr11 = pf_open("/usr/lib/fonts/fixedwidthfonts/screen.r.11");
  91.     if (screenr11 == NULL) {
  92.     fprintf(stderr, "Couldn't open /usr/lib/fonts/fixedwidthfonts/screen.r.11\n");
  93.     fprintf(stderr, "Using default system font.  The control panel may suffer problems\n");
  94.     fprintf(stderr, "because of this.\n");
  95.     screenr11 = pf_default();
  96.     }
  97.     screenr12 = pf_open("/usr/lib/fonts/fixedwidthfonts/screen.r.12");
  98.     if (screenr12 == NULL) {
  99.     fprintf(stderr, "Couldn't open /usr/lib/fonts/fixedwidthfonts/screen.r.12\n");
  100.     fprintf(stderr, "Using default system font.  The default popups may suffer\n");
  101.     fprintf(stderr, "because of this.\n");
  102.     screenr12 = pf_default();
  103.     }
  104.     panel = window_create(frame, PANEL, WIN_FONT, screenr11, 0);
  105.     pan_time = panel_create_item(panel, PANEL_MESSAGE,
  106.                  PANEL_ITEM_X, ATTR_COL(5),
  107.                  PANEL_ITEM_Y, ATTR_ROW(0),
  108.                  PANEL_LABEL_STRING, "         ", 0);
  109.     panel_create_item(panel, PANEL_MESSAGE,
  110.               PANEL_LABEL_STRING, "Time:",
  111.               PANEL_ITEM_X, ATTR_COL(0),
  112.               PANEL_ITEM_Y, ATTR_ROW(0),
  113.               0);
  114.     show_time(0);
  115.     pan_pos = panel_create_item(panel, PANEL_MESSAGE,
  116.                 PANEL_ITEM_X, ATTR_COL(19),
  117.                 PANEL_ITEM_Y, ATTR_ROW(0),
  118.                 PANEL_LABEL_STRING, "         ", 0);
  119.     panel_create_item(panel, PANEL_MESSAGE,
  120.               PANEL_LABEL_STRING, "Pos:",
  121.               PANEL_ITEM_X, ATTR_COL(15),
  122.               PANEL_ITEM_Y, ATTR_ROW(0),
  123.               0);
  124.     pan_state = panel_create_item(panel, PANEL_MESSAGE,
  125.                   PANEL_ITEM_X, ATTR_COL(7),
  126.                   PANEL_ITEM_Y, ATTR_ROW(1),
  127.                   PANEL_LABEL_STRING, "    ",0);
  128.     panel_create_item(panel, PANEL_MESSAGE,
  129.               PANEL_LABEL_STRING, "State:",
  130.               PANEL_ITEM_X, ATTR_COL(0),
  131.               PANEL_ITEM_Y, ATTR_ROW(1),
  132.               0);
  133.     pan_planes = panel_create_item(panel, PANEL_MESSAGE,
  134.                    PANEL_ITEM_X, ATTR_COL(19),
  135.                    PANEL_ITEM_Y, ATTR_ROW(1),
  136.                    PANEL_LABEL_STRING, "     ",
  137.                    0);
  138.     panel_create_item(panel, PANEL_MESSAGE,
  139.               PANEL_LABEL_STRING, "Planes:",
  140.               PANEL_ITEM_X, ATTR_COL(12),
  141.               PANEL_ITEM_Y, ATTR_ROW(1),
  142.               0);
  143.     show_planes(AMASK);
  144.     pan_mode = panel_create_item(panel, PANEL_CYCLE,
  145.                  PANEL_LABEL_STRING, "Mode:",
  146.                  PANEL_NOTIFY_PROC, mode_proc,
  147.                  PANEL_ITEM_X, ATTR_COL(0),
  148.                  PANEL_ITEM_Y, ATTR_ROW(2),
  149.                  PANEL_LABEL_X, ATTR_COL(0),
  150.                  PANEL_CHOICE_STRINGS,
  151.                    "Edit", "Probe", "Plane Edit", 0,
  152.                  PANEL_VALUE_X, pan_lvalue, 0);
  153.     pan_stop_on = panel_create_item(panel, PANEL_CYCLE,
  154.                     PANEL_LABEL_STRING, "Stop on:",
  155.                     PANEL_NOTIFY_PROC, stop_on_proc,
  156.                     PANEL_ITEM_X, ATTR_COL(0),
  157.                     PANEL_ITEM_Y, ATTR_ROW(3),
  158.                     PANEL_LABEL_X, ATTR_COL(0),
  159.                     PANEL_CHOICE_STRINGS,
  160.                    "Never", "No change", "All zero", 0,
  161.                     PANEL_VALUE_X, pan_lvalue, 0);
  162.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  163.                MENU_STRING_ITEM, "Run", run_proc,
  164.                MENU_STRING_ITEM, "Skip", skip_run_proc,
  165.                MENU_STRING_ITEM, "Bounded", bound_run_proc,
  166.                MENU_STRING_ITEM, "Skip/Bounded", sb_run_proc,
  167.                MENU_STRING_ITEM, "Screenful", screenful_proc,
  168.                MENU_STRING_ITEM, "Step", step_proc,
  169.                MENU_STRING_ITEM, "Single Skip", skip_proc,
  170.                MENU_STRING_ITEM, "Run Local", run_local_proc,
  171.                MENU_STRING_ITEM, "Step Local", step_local_proc,
  172.                0);
  173.     panel_create_item(panel, PANEL_BUTTON,
  174.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Run", 8, NULL),
  175.               PANEL_ITEM_X, 10,
  176.               PANEL_ITEM_Y, 90,
  177.               PANEL_EVENT_PROC, button_event_proc,
  178.               PANEL_NOTIFY_PROC, do_first_item_proc,
  179.               PANEL_CLIENT_DATA, tmp_menu,
  180.               0);
  181.     defaults_image_menu = menu_create(
  182.                   MENU_STRING_ITEM, "Save in Image-dir", 1,
  183.                   MENU_STRING_ITEM, "Save uncompressed", 2,
  184.                   MENU_STRING_ITEM, "Set Image-dir", 3,
  185.                   MENU_STRING_ITEM, "Disable auto-change", 4,
  186.                   MENU_ACTION_PROC, defaults_image_menu_proc,
  187.                   0);
  188.     defaults_rule_menu = menu_create(
  189.                   MENU_STRING_ITEM, "Save in Table-dir", 1,
  190.                   MENU_STRING_ITEM, "Save uncompressed", 2,
  191.                   MENU_STRING_ITEM, "Set Table-dir", 3,
  192.                   MENU_STRING_ITEM, "Set Fcn-dir", 4,
  193.                   MENU_STRING_ITEM, "Disable auto-change", 5,
  194.                   MENU_ACTION_PROC, defaults_rule_menu_proc,
  195.                   0);
  196.     defaults_cmap_menu = menu_create(
  197.                  MENU_STRING_ITEM, "Save in Cmap-dir", 1,
  198.                  MENU_STRING_ITEM, "Set Cmap-dir", 2,
  199.                  MENU_ACTION_PROC, defaults_cmap_menu_proc,
  200.                   0);
  201.     defaults_CM_menu = menu_create(
  202.                    MENU_STRING_ITEM, "host", 1,
  203.                    MENU_STRING_ITEM, "port", 2,
  204.                    MENU_STRING_ITEM, "run-delay", 3,
  205.                    MENU_STRING_ITEM, "Enable FB display", 4,
  206.                    MENU_STRING_ITEM, "Disable Sun display", 5,
  207.                    MENU_STRING_ITEM, "Set CM Image-dir", 6,
  208.                    MENU_STRING_ITEM, "Set CM Fcn-dir", 7,
  209.                    MENU_STRING_ITEM, "Set CM LT-dir", 8,
  210.                    MENU_STRING_ITEM, "Set zoom factor", 9,
  211.                    MENU_STRING_ITEM, "Set pan", 10,
  212.                    MENU_ACTION_PROC, defaults_CM_menu_proc,
  213.                    0);
  214.     defaults_menu = menu_create(
  215.                 MENU_ACTION_ITEM, "Image", def_im_popup_proc,
  216.                 MENU_ACTION_ITEM, "Rule", def_rule_popup_proc,
  217.                 MENU_ACTION_ITEM, "Cmap", def_cmap_popup_proc,
  218.                 MENU_ACTION_ITEM, "CM", def_CM_popup_proc,
  219.                 MENU_ACTION_ITEM, "Change nhood / #states",
  220.                    change_stuff_proc,
  221.                 MENU_ACTION_ITEM, "Change image-size",
  222.                    change_image_size_proc,
  223.                 MENU_ACTION_ITEM, "Change working directory",
  224.                    chdir_proc,
  225.                 0);
  226.     defaults_button = panel_create_item(panel, PANEL_BUTTON,
  227.                 PANEL_LABEL_IMAGE,
  228.                   panel_button_image(panel,"Defaults",8,NULL),
  229.                 PANEL_ITEM_X, 110,
  230.                 PANEL_ITEM_Y, 90,
  231.                 PANEL_EVENT_PROC, button_event_proc,
  232.                 PANEL_CLIENT_DATA, defaults_menu,
  233.                 0);
  234.     image_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  235.                  MENU_STRING_ITEM, "Load", iload,
  236.                  MENU_STRING_ITEM, "Save", isave_proc,
  237.                  MENU_STRING_ITEM, "Load/Resize", iload_resize,
  238.                  MENU_STRING_ITEM, "Save/Resize", isave_resize,
  239.                  MENU_STRING_ITEM, "Save/Raster", isave_raster,
  240.                  MENU_STRING_ITEM, "Load/CAM6", iload_CAM6,
  241.                  MENU_STRING_ITEM, "Save/CAM6", isave_CAM6,
  242.                  MENU_STRING_ITEM, "Enter", ienter,
  243.                  MENU_STRING_ITEM, "Clear", iclear,
  244.                  MENU_STRING_ITEM, "Swap", iswap,
  245.                  MENU_STRING_ITEM, "Copy", icopy,
  246.                  MENU_STRING_ITEM, "Invert", iinvert,
  247.                  0);
  248.     panel_create_item(panel, PANEL_BUTTON,
  249.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Image", 8, NULL),
  250.               PANEL_ITEM_X, 10,
  251.               PANEL_ITEM_Y, 90+button_vsize,
  252.               PANEL_EVENT_PROC, button_event_proc,
  253.               PANEL_NOTIFY_PROC, do_first_item_proc,
  254.               PANEL_CLIENT_DATA, image_menu,
  255.               0);
  256.     rules_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  257.                  MENU_STRING_ITEM, "Load", load_rule,
  258.                  MENU_STRING_ITEM, "Save", tsave_proc,
  259.                  MENU_STRING_ITEM, "Clear", tclear_proc,
  260.                  MENU_STRING_ITEM, "Alter", talter,
  261.                  MENU_STRING_ITEM, "Disable symmetry", tsymmetry,
  262.                  MENU_STRING_ITEM, "Generate", tgenerate,
  263.                  MENU_STRING_ITEM, "Lambda", lambda_proc,
  264.                  MENU_STRING_ITEM, "Lambda Step", lambda_step_proc,
  265.                  MENU_STRING_ITEM, "Rho", rho_proc,
  266.                  MENU_STRING_ITEM, "Set parm1", edit_parm1,
  267.                  MENU_STRING_ITEM, "Set parm2", edit_parm2,
  268.                  0);
  269.     panel_create_item(panel, PANEL_BUTTON,
  270.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Rules", 8, NULL),
  271.               PANEL_ITEM_X, 110,
  272.               PANEL_ITEM_Y, 90+button_vsize,
  273.               PANEL_EVENT_PROC, button_event_proc,
  274.               PANEL_NOTIFY_PROC, do_first_item_proc,
  275.               PANEL_CLIENT_DATA, rules_menu,
  276.               0);
  277.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  278.                MENU_STRING_ITEM, "Load", bload,
  279.                MENU_STRING_ITEM, "Save", bsave,
  280.                MENU_STRING_ITEM, "Swap", bswap,
  281.                MENU_STRING_ITEM, "Xor", bxor,
  282.                MENU_STRING_ITEM, "Or", bor,
  283.                MENU_STRING_ITEM, "And", band,
  284.                0);
  285.     panel_create_item(panel, PANEL_BUTTON,
  286.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Buffer", 8, NULL),
  287.               PANEL_ITEM_X, 10,
  288.               PANEL_ITEM_Y, 90+2*button_vsize,
  289.               PANEL_EVENT_PROC, button_event_proc,
  290.               PANEL_NOTIFY_PROC, do_first_item_proc,
  291.               PANEL_CLIENT_DATA, tmp_menu,
  292.               0);
  293.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  294.                MENU_STRING_ITEM, "Array", clear_proc,
  295.                MENU_STRING_ITEM, "Zero time", zero_proc,
  296.                0);
  297.     panel_create_item(panel, PANEL_BUTTON,
  298.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Clear", 8, NULL),
  299.               PANEL_ITEM_X, 110,
  300.               PANEL_ITEM_Y, 90+2*button_vsize,
  301.               PANEL_EVENT_PROC, button_event_proc,
  302.               PANEL_NOTIFY_PROC, do_first_item_proc,
  303.               PANEL_CLIENT_DATA, tmp_menu,
  304.               0);
  305.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  306.                MENU_STRING_ITEM, "Learn", learn_proc,
  307.                0);
  308.     panel_create_item(panel, PANEL_BUTTON,
  309.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Learn", 8, NULL),
  310.               PANEL_ITEM_X, 10,
  311.               PANEL_ITEM_Y, 90+3*button_vsize,
  312.               PANEL_EVENT_PROC, button_event_proc,
  313.               PANEL_NOTIFY_PROC, do_first_item_proc,
  314.               PANEL_CLIENT_DATA, tmp_menu,
  315.               0);
  316.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  317.                MENU_STRING_ITEM, "Set", set_proc,
  318.                0);
  319.     panel_create_item(panel, PANEL_BUTTON,
  320.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Set", 8, NULL),
  321.               PANEL_ITEM_X, 110,
  322.               PANEL_ITEM_Y, 90+3*button_vsize,
  323.               PANEL_EVENT_PROC, button_event_proc,
  324.               PANEL_NOTIFY_PROC, do_first_item_proc,
  325.               PANEL_CLIENT_DATA, tmp_menu,
  326.               0);
  327.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  328.                MENU_STRING_ITEM, "Toggle", zoom_proc,
  329.                MENU_STRING_ITEM, "Magnify", magnify_proc,
  330.                0);
  331.     panel_create_item(panel, PANEL_BUTTON,
  332.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Zoom", 8, NULL),
  333.               PANEL_ITEM_X, 10,
  334.               PANEL_ITEM_Y, 90+4*button_vsize,
  335.               PANEL_EVENT_PROC, button_event_proc,
  336.               PANEL_NOTIFY_PROC, do_first_item_proc,
  337.               PANEL_CLIENT_DATA, tmp_menu,
  338.               0);
  339.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  340.                MENU_STRING_ITEM, "Closeup", closeup_proc,
  341.                0);
  342.     panel_create_item(panel, PANEL_BUTTON,
  343.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Closeup", 8, NULL),
  344.               PANEL_ITEM_X, 110,
  345.               PANEL_ITEM_Y, 90+4*button_vsize,
  346.               PANEL_EVENT_PROC, button_event_proc,
  347.               PANEL_NOTIFY_PROC, do_first_item_proc,
  348.               PANEL_CLIENT_DATA, tmp_menu,
  349.               0);
  350.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  351.                MENU_STRING_ITEM, "Zoom in", zoom_in_proc,
  352.                0);
  353.     panel_create_item(panel, PANEL_BUTTON,
  354.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Zoom in", 8, NULL),
  355.               PANEL_ITEM_X, 10,
  356.               PANEL_ITEM_Y, 90+5*button_vsize,
  357.               PANEL_EVENT_PROC, button_event_proc,
  358.               PANEL_NOTIFY_PROC, do_first_item_proc,
  359.               PANEL_CLIENT_DATA, tmp_menu,
  360.               0);
  361.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  362.                MENU_STRING_ITEM, "Zoom out", zoom_out_proc,
  363.                0);
  364.     panel_create_item(panel, PANEL_BUTTON,
  365.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Zoom out", 8, NULL),
  366.               PANEL_ITEM_X, 110,
  367.               PANEL_ITEM_Y, 90+5*button_vsize,
  368.               PANEL_EVENT_PROC, button_event_proc,
  369.               PANEL_NOTIFY_PROC, do_first_item_proc,
  370.               PANEL_CLIENT_DATA, tmp_menu,
  371.               0);
  372.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  373.                MENU_STRING_ITEM, "Quick random", quick_random_proc,
  374.                MENU_STRING_ITEM, "General random", general_random_proc,
  375.                MENU_STRING_ITEM, "Horizontal line", horiz_line_proc,
  376.                MENU_STRING_ITEM, "Vertical line", vert_line_proc,
  377.                MENU_STRING_ITEM, "Arbitrary line", arb_line_proc,
  378.                MENU_STRING_ITEM, "Hollow_circle", hollow_circ_proc,
  379.                MENU_STRING_ITEM, "Shaded circle", shaded_circ_proc,
  380.                0);
  381.     panel_create_item(panel, PANEL_BUTTON,
  382.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Draw", 8, NULL),
  383.               PANEL_ITEM_X, 10,
  384.               PANEL_ITEM_Y, 90+6*button_vsize,
  385.               PANEL_EVENT_PROC, button_event_proc,
  386.               PANEL_NOTIFY_PROC, do_first_item_proc,
  387.               PANEL_CLIENT_DATA, tmp_menu,
  388.               0);
  389.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  390.                MENU_STRING_ITEM, "Load", cmap_load,
  391.                MENU_STRING_ITEM, "Save", cmap_save_proc,
  392.                MENU_STRING_ITEM, "Alter", cmap_alter,
  393.                0);
  394.     panel_create_item(panel, PANEL_BUTTON,
  395.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Color", 8, NULL),
  396.               PANEL_ITEM_X, 110,
  397.               PANEL_ITEM_Y, 90+6*button_vsize,
  398.               PANEL_EVENT_PROC, button_event_proc,
  399.               PANEL_NOTIFY_PROC, do_first_item_proc,
  400.               PANEL_CLIENT_DATA, tmp_menu,
  401.               0);
  402.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  403.                MENU_STRING_ITEM, "Reset", plane_reset_proc,
  404.                MENU_STRING_ITEM, "Display", plane_display_proc,
  405.                MENU_STRING_ITEM, "Clear", pclear,
  406.                MENU_STRING_ITEM, "Invert", pinvert,
  407.                0);
  408.     panel_create_item(panel, PANEL_BUTTON,
  409.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Planes", 8, NULL),
  410.               PANEL_ITEM_X, 10,
  411.               PANEL_ITEM_Y, 90+7*button_vsize,
  412.               PANEL_EVENT_PROC, button_event_proc,
  413.               PANEL_NOTIFY_PROC, do_first_item_proc,
  414.               PANEL_CLIENT_DATA, tmp_menu,
  415.               0);
  416.     CM_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  417.                MENU_STRING_ITEM, "Connect to CM", CM_connect,
  418.                MENU_STRING_ITEM, "Send image", CM_send_image,
  419.                MENU_STRING_ITEM, "Get image", CM_get_image_proc,
  420.                MENU_STRING_ITEM, "Send LT", CM_send_LT,
  421.                MENU_STRING_ITEM, "Send cmap", CM_send_cmap,
  422.                MENU_STRING_ITEM, "Disconnect", CM_disconnect,
  423.                MENU_STRING_ITEM, "Load image from CMFE", CM_load_image_proc,
  424.                MENU_STRING_ITEM, "Load rule from CMFE", CM_load_rule_proc,
  425.                MENU_STRING_ITEM, "Clear CM array", CM_clear,
  426.                MENU_STRING_ITEM, "CM quick random", CM_quick_random_proc,
  427.                MENU_STRING_ITEM, "CM general random", CM_general_random_proc,
  428.                0);
  429.      panel_create_item(panel, PANEL_BUTTON,
  430.                PANEL_LABEL_IMAGE, panel_button_image(panel, "CM", 8, NULL),
  431.                PANEL_ITEM_X, 110,
  432.                PANEL_ITEM_Y, 90+7*button_vsize,
  433.                PANEL_EVENT_PROC, button_event_proc,
  434.                PANEL_NOTIFY_PROC, do_first_item_proc,
  435.                PANEL_CLIENT_DATA, CM_menu,
  436.                0);
  437.      tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  438.                MENU_STRING_ITEM, "Sequence 1", sequence1_proc,
  439.                MENU_STRING_ITEM, "Sequence 2", sequence2_proc,
  440.                MENU_STRING_ITEM, "Sequence 3", sequence3_proc,
  441.                MENU_STRING_ITEM, "Sequence 4", sequence4_proc,
  442.                MENU_STRING_ITEM, "Sequence 5", sequence5_proc,
  443.                0);
  444.     panel_create_item(panel, PANEL_BUTTON,
  445.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Sequence", 8, NULL),
  446.               PANEL_ITEM_X, 10,
  447.               PANEL_ITEM_Y, 90+8*button_vsize,
  448.               PANEL_EVENT_PROC, button_event_proc,
  449.               PANEL_NOTIFY_PROC, do_first_item_proc,
  450.               PANEL_CLIENT_DATA, tmp_menu,
  451.               0);
  452.     tmp_menu = menu_create(MENU_NOTIFY_PROC, menu_notify_proc,
  453.                MENU_STRING_ITEM, "Quit", quit_proc,
  454.                0);
  455.     panel_create_item(panel, PANEL_BUTTON,
  456.               PANEL_LABEL_IMAGE, panel_button_image(panel, "Quit", 8, NULL),
  457.               PANEL_ITEM_X, 110,
  458.               PANEL_ITEM_Y, 90+8*button_vsize,
  459.               PANEL_EVENT_PROC, button_event_proc,
  460.               PANEL_NOTIFY_PROC, do_first_item_proc,
  461.               PANEL_CLIENT_DATA, tmp_menu,
  462.               0);
  463.     for (i=0; i < NUM_MSGS; i++) {
  464.     pan_msg[i] = panel_create_item(panel, PANEL_MESSAGE,
  465.                        PANEL_ITEM_X, 10,
  466.                        PANEL_ITEM_Y, 270+i*20,
  467.                        PANEL_LABEL_STRING, "                                ",
  468.                        0);
  469.     }
  470.     panel_create_item(panel, PANEL_BUTTON,
  471.               PANEL_LABEL_IMAGE, panel_button_image(panel,"Up",6,NULL),
  472.               PANEL_ITEM_X, 80,
  473.               PANEL_ITEM_Y, 450,
  474.               PANEL_MENU_CHOICE_STRINGS, "Up", 0,
  475.               PANEL_SHOW_MENU, TRUE,
  476.               PANEL_NOTIFY_PROC, up_proc,
  477.               0);
  478.     panel_create_item(panel, PANEL_BUTTON,
  479.               PANEL_LABEL_IMAGE, panel_button_image(panel,"Left",6,NULL),
  480.               PANEL_ITEM_X, 20,
  481.               PANEL_ITEM_Y, 470,
  482.               PANEL_MENU_CHOICE_STRINGS, "Left", 0,
  483.               PANEL_SHOW_MENU, TRUE,
  484.               PANEL_NOTIFY_PROC, left_proc,
  485.               0);
  486.     panel_create_item(panel, PANEL_BUTTON,
  487.               PANEL_LABEL_IMAGE, panel_button_image(panel,"Shift",6,NULL),
  488.               PANEL_ITEM_X, 80,
  489.               PANEL_ITEM_Y, 470,
  490.               PANEL_MENU_CHOICE_STRINGS, "Shift", 0,
  491.               PANEL_SHOW_MENU, TRUE,
  492.               PANEL_NOTIFY_PROC, shift_proc,
  493.               0);
  494.     panel_create_item(panel, PANEL_BUTTON,
  495.               PANEL_LABEL_IMAGE, panel_button_image(panel,"Right",6,NULL),
  496.               PANEL_ITEM_X, 140,
  497.               PANEL_ITEM_Y, 470,
  498.               PANEL_MENU_CHOICE_STRINGS, "Right", 0,
  499.               PANEL_SHOW_MENU, TRUE,
  500.               PANEL_NOTIFY_PROC, right_proc,
  501.               0);
  502.     panel_create_item(panel, PANEL_BUTTON,
  503.               PANEL_LABEL_IMAGE, panel_button_image(panel,"Down",6,NULL),
  504.               PANEL_ITEM_X, 80,
  505.               PANEL_ITEM_Y, 490,
  506.               PANEL_MENU_CHOICE_STRINGS, "Down", 0,
  507.               PANEL_SHOW_MENU, TRUE,
  508.               PANEL_NOTIFY_PROC, down_proc,
  509.               0);
  510.     window_fit_width(panel);
  511.     cursor = cursor_create(CURSOR_SHOW_CROSSHAIRS, TRUE,
  512.                CURSOR_IMAGE, &cursor_pixrect,
  513.                CURSOR_OP, PIX_SRC ^ PIX_DST,
  514.                CURSOR_CROSSHAIR_OP, PIX_SRC ^ PIX_DST,
  515.                CURSOR_XHOT, 8, CURSOR_YHOT, 8,
  516.                CURSOR_CROSSHAIR_COLOR, curr_color,
  517.                CURSOR_CROSSHAIR_THICKNESS, 2,
  518.                CURSOR_CROSSHAIR_LENGTH, 12,
  519.                CURSOR_CROSSHAIR_GAP, 5, 0);
  520.     canvas = window_create(frame, CANVAS,
  521.                CANVAS_WIDTH, MAXSIZE, CANVAS_HEIGHT, MAXSIZE,
  522.                WIN_HEIGHT, MAXSIZE, WIN_WIDTH, MAXSIZE,
  523.                WIN_EVENT_PROC, screen_event_proc,
  524.                WIN_CONSUME_KBD_EVENT, WIN_ASCII_EVENTS,
  525.                WIN_CONSUME_PICK_EVENT, WIN_IN_TRANSIT_EVENTS,
  526.                CANVAS_RETAINED, FALSE,
  527.                CANVAS_REPAINT_PROC, display_image,
  528.                WIN_CURSOR, cursor, 0);
  529.     window_fit(frame);
  530.     window_set(panel, WIN_HEIGHT, WIN_EXTEND_TO_EDGE, 0);
  531.     pw = canvas_pixwin(canvas);
  532.     window_pw = (Pixwin *)window_get(frame, WIN_PIXWIN);
  533.     panel_pw = (Pixwin *)window_get(panel, WIN_PIXWIN);
  534.  
  535.     icon = icon_create(ICON_IMAGE, &icon_pixrect, 0);
  536.     window_set(frame, FRAME_ICON, icon, 0);
  537.  
  538.     edit_menu = menu_create(MENU_NROWS, 4, 0);
  539.     for (i = 1; i < 8; i++) {
  540.     str = (char *) malloc(2);
  541.     str[0] = to_char(i);
  542.     str[1] = NULL;
  543.     menu_set(edit_menu, MENU_STRING_ITEM, str, i, 0);
  544.     }
  545.     probe_menu = menu_create(MENU_STRINGS, "Alter", 0, 0);
  546.     planeedit_menu = menu_create(MENU_NROWS, 8, 0);
  547.     for (i = 0; i < 8; i++) {
  548.     str = (char *) malloc(10);
  549.     sprintf(str, "Plane %d", i);
  550.     menu_set(planeedit_menu, MENU_STRING_ITEM, str, (1 << i), 0);
  551.     }
  552.     change_canvas_menus();
  553.     popup = window_create(frame, FRAME, FRAME_SHOW_LABEL, FALSE,
  554.               WIN_FONT, screenr11,
  555.               WIN_SHOW, FALSE, 0);
  556.     pop_panel = window_create(popup, PANEL, WIN_FONT, screenr11, 0);
  557.     pop_input = panel_create_item(pop_panel, PANEL_TEXT,
  558.                   PANEL_NOTIFY_PROC, return_proc,
  559.                   PANEL_VALUE_STORED_LENGTH, BUFLEN,
  560.                   PANEL_VALUE_DISPLAY_LENGTH, POP_DISP_LEN,
  561.                   PANEL_VALUE, "", 0);
  562.     window_fit(pop_panel);
  563.     window_fit(popup);
  564.  
  565.     def_im_popup = window_create(frame, FRAME,
  566.                  /* FRAME_SHOW_LABEL, FALSE, */
  567.                  FRAME_LABEL, "Image defaults",
  568.                  WIN_SHOW, FALSE,
  569.                  WIN_FONT, screenr12,
  570.                  0);
  571.     def_im_panel = window_create(def_im_popup, PANEL, 0);
  572.     def_im_save_item = two_item_cycle(def_im_panel, "Save in:",
  573.                       "Current working dir", "Image-dir",
  574.                       1, 2);
  575.     def_im_compress_item = two_item_cycle(def_im_panel, "Save:",
  576.                       "Compressed", "Uncompressed",
  577.                       1, 4);
  578.     def_im_2Dalways_item = two_item_cycle(def_im_panel, "Load/save 2D always:",
  579.                       "False", "True",
  580.                       1, 6);
  581.     def_im_imagedir_item = panel_create_item(def_im_panel, PANEL_TEXT,
  582.                          PANEL_LABEL_STRING, "Image-dir:",
  583.                          PANEL_VALUE, Image_dir,
  584.                          PANEL_ITEM_X, ATTR_COL(1),
  585.                          PANEL_ITEM_Y, ATTR_ROW(8),
  586.                          0);
  587.     def_im_autochange_item = two_item_cycle(def_im_panel, "Auto change:",
  588.                         "Enabled", "Disabled",
  589.                         1, 10);
  590.     panel_create_item(def_im_panel, PANEL_BUTTON,
  591.               PANEL_LABEL_IMAGE, panel_button_image(def_im_panel,"Done",0,0),
  592.               PANEL_NOTIFY_PROC, def_im_done_proc,
  593.               PANEL_ITEM_X, ATTR_COL(1),
  594.               PANEL_ITEM_Y, ATTR_ROW(12),
  595.               0);
  596.     window_fit(def_im_panel);
  597.     window_fit(def_im_popup);
  598.  
  599.     def_rule_popup = window_create(frame, FRAME,
  600.                    /* FRAME_SHOW_LABEL, FALSE, */
  601.                    FRAME_LABEL, "Rule defaults",
  602.                    WIN_SHOW, FALSE,
  603.                    WIN_FONT, screenr12,
  604.                    0);
  605.     def_rule_panel = window_create(def_rule_popup, PANEL, 0);
  606.     def_rule_save_item = two_item_cycle(def_rule_panel, "Save in:",
  607.                       "Current working dir", "Table-dir",
  608.                       1, 2);
  609.     def_rule_compress_item = two_item_cycle(def_rule_panel, "Save:",
  610.                       "Compressed", "Uncompressed",
  611.                       1, 4);
  612.     def_rule_tabledir_item = panel_create_item(def_rule_panel, PANEL_TEXT,
  613.                          PANEL_LABEL_STRING, "Table-dir:",
  614.                          PANEL_VALUE, Table_dir,
  615.                          PANEL_ITEM_X, ATTR_COL(1),
  616.                          PANEL_ITEM_Y, ATTR_ROW(6),
  617.                          0);
  618.     def_rule_fcndir_item = panel_create_item(def_rule_panel, PANEL_TEXT,
  619.                          PANEL_LABEL_STRING, "Fcn-dir:",
  620.                          PANEL_VALUE, Fcn_dir,
  621.                          PANEL_ITEM_X, ATTR_COL(1),
  622.                          PANEL_ITEM_Y, ATTR_ROW(8),
  623.                          0);
  624.     def_rule_autochange_item = two_item_cycle(def_rule_panel, "Auto change:",
  625.                         "Enabled", "Disabled",
  626.                         1, 10);
  627.     panel_create_item(def_rule_panel, PANEL_BUTTON,
  628.               PANEL_LABEL_IMAGE, panel_button_image(def_rule_panel,"Done",0,0),
  629.               PANEL_NOTIFY_PROC, def_rule_done_proc,
  630.               PANEL_ITEM_X, ATTR_COL(1),
  631.               PANEL_ITEM_Y, ATTR_ROW(12),
  632.               0);
  633.     window_fit(def_rule_panel);
  634.     window_fit(def_rule_popup);
  635.  
  636.     def_cmap_popup = window_create(frame, FRAME,
  637.                    /* FRAME_SHOW_LABEL, FALSE, */
  638.                    FRAME_LABEL, "Cmap defaults",
  639.                    WIN_SHOW, FALSE,
  640.                    WIN_FONT, screenr12,
  641.                    0);
  642.     def_cmap_panel = window_create(def_cmap_popup, PANEL, 0);
  643.     def_cmap_save_item = two_item_cycle(def_cmap_panel, "Save in:",
  644.                       "Current working dir", "Cmap-dir",
  645.                       1, 2);
  646.     def_cmap_compress_item = two_item_cycle(def_cmap_panel, "Save:",
  647.                       "Compressed", "Uncompressed",
  648.                       1, 4);
  649.     def_cmap_cmapdir_item = panel_create_item(def_cmap_panel, PANEL_TEXT,
  650.                          PANEL_LABEL_STRING, "Cmap-dir:",
  651.                          PANEL_VALUE, Cmap_dir,
  652.                          PANEL_ITEM_X, ATTR_COL(1),
  653.                          PANEL_ITEM_Y, ATTR_ROW(6),
  654.                          0);
  655.     panel_create_item(def_cmap_panel, PANEL_BUTTON,
  656.               PANEL_LABEL_IMAGE, panel_button_image(def_cmap_panel,"Done",0,0),
  657.               PANEL_NOTIFY_PROC, def_cmap_done_proc,
  658.               PANEL_ITEM_X, ATTR_COL(1),
  659.               PANEL_ITEM_Y, ATTR_ROW(8),
  660.               0);
  661.     window_fit(def_cmap_panel);
  662.     window_fit(def_cmap_popup);
  663.  
  664.     def_CM_popup = window_create(frame, FRAME,
  665.                  /* FRAME_SHOW_LABEL, FALSE,*/
  666.                  FRAME_LABEL, "CM defaults",
  667.                  WIN_SHOW, FALSE,
  668.                  WIN_FONT, screenr12,
  669.                  0);
  670.     def_CM_panel = window_create(def_CM_popup, PANEL, 0);
  671.     def_CM_host_item = panel_create_item(def_CM_panel, PANEL_TEXT,
  672.                          PANEL_LABEL_STRING, "CMFE host:",
  673.                          PANEL_VALUE, CM_hostname,
  674.                          PANEL_ITEM_X, ATTR_COL(1),
  675.                          PANEL_ITEM_Y, ATTR_ROW(2),
  676.                          0);
  677.     sprintf(CM_port_str, "%d", CM_port);
  678.     def_CM_port_item = panel_create_item(def_CM_panel, PANEL_TEXT,
  679.                          PANEL_LABEL_STRING, "CMFE port:",
  680.                          PANEL_VALUE, CM_port_str,
  681.                          PANEL_ITEM_X, ATTR_COL(1),
  682.                          PANEL_ITEM_Y, ATTR_ROW(4),
  683.                          0);
  684.     def_CM_rundelay_item = panel_create_item(def_CM_panel, PANEL_SLIDER,
  685.                          PANEL_LABEL_STRING, "Run delay:",
  686.                          PANEL_VALUE, 0,
  687.                          PANEL_MIN_VALUE, 0,
  688.                          PANEL_MAX_VALUE, 1000000,
  689.                          PANEL_SLIDER_WIDTH, 300,
  690.                          PANEL_ITEM_X, ATTR_COL(1),
  691.                          PANEL_ITEM_Y, ATTR_ROW(6),
  692.                          0);
  693.     def_CM_display_item = panel_create_item(def_CM_panel, PANEL_TOGGLE,
  694.                         PANEL_LABEL_STRING, "Display on:",
  695.                         PANEL_LAYOUT, PANEL_HORIZONTAL,
  696.                         PANEL_CHOICE_STRINGS,
  697.                           "CM Frame-buffer",
  698.                           "Sun display",
  699.                           0,
  700.                         PANEL_TOGGLE_VALUE, 1, TRUE,
  701.                         PANEL_ITEM_X, ATTR_COL(1),
  702.                         PANEL_ITEM_Y, ATTR_ROW(8),
  703.                         0);
  704.     def_CM_imagedir_item = panel_create_item(def_CM_panel, PANEL_TEXT,
  705.                          PANEL_LABEL_STRING, "Image-dir:",
  706.                          PANEL_ITEM_X, ATTR_COL(1),
  707.                          PANEL_ITEM_Y, ATTR_ROW(10),
  708.                          0);
  709.     def_CM_fcndir_item = panel_create_item(def_CM_panel, PANEL_TEXT,
  710.                          PANEL_LABEL_STRING, "Fcn-dir:",
  711.                          PANEL_ITEM_X, ATTR_COL(1),
  712.                          PANEL_ITEM_Y, ATTR_ROW(12),
  713.                          0);
  714.     def_CM_LTdir_item = panel_create_item(def_CM_panel, PANEL_TEXT,
  715.                          PANEL_LABEL_STRING, "LT-dir:",
  716.                          PANEL_ITEM_X, ATTR_COL(1),
  717.                          PANEL_ITEM_Y, ATTR_ROW(14),
  718.                          0);
  719.     def_CM_zoom_item = panel_create_item(def_CM_panel, PANEL_SLIDER,
  720.                      PANEL_LABEL_STRING, "Zoom factor:",
  721.                      PANEL_VALUE, CM_zoom,
  722.                      PANEL_MIN_VALUE, 0,
  723.                      PANEL_MAX_VALUE, 127,
  724.                      PANEL_SLIDER_WIDTH, 300,
  725.                      PANEL_ITEM_X, ATTR_COL(1),
  726.                      PANEL_ITEM_Y, ATTR_ROW(16),
  727.                      PANEL_NOTIFY_LEVEL, PANEL_ALL,
  728.                      PANEL_NOTIFY_PROC, CM_send_zoom_proc,
  729.                      0);
  730.     def_CM_panx_item = panel_create_item(def_CM_panel, PANEL_SLIDER,
  731.                      PANEL_LABEL_STRING, "X pan:",
  732.                      PANEL_VALUE, CM_panx,
  733.                      PANEL_MIN_VALUE, 0,
  734.                      PANEL_MAX_VALUE, 512,
  735.                      PANEL_SLIDER_WIDTH, 300,
  736.                      PANEL_ITEM_X, ATTR_COL(1),
  737.                      PANEL_ITEM_Y, ATTR_ROW(18),
  738.                      PANEL_NOTIFY_LEVEL, PANEL_ALL,
  739.                      PANEL_NOTIFY_PROC, CM_send_panx_proc,
  740.                      0);
  741.     def_CM_pany_item = panel_create_item(def_CM_panel, PANEL_SLIDER,
  742.                      PANEL_LABEL_STRING, "Y pan:",
  743.                      PANEL_VALUE, CM_pany,
  744.                      PANEL_MIN_VALUE, 0,
  745.                      PANEL_MAX_VALUE, 512,
  746.                      PANEL_SLIDER_WIDTH, 300,
  747.                      PANEL_ITEM_X, ATTR_COL(1),
  748.                      PANEL_ITEM_Y, ATTR_ROW(20),
  749.                      PANEL_NOTIFY_LEVEL, PANEL_ALL,
  750.                      PANEL_NOTIFY_PROC, CM_send_pany_proc,
  751.                      0);
  752.     panel_create_item(def_CM_panel, PANEL_BUTTON,
  753.               PANEL_LABEL_IMAGE, panel_button_image(def_CM_panel,"Done",0,0),
  754.               PANEL_NOTIFY_PROC, def_CM_done_proc,
  755.               PANEL_ITEM_X, ATTR_COL(1),
  756.               PANEL_ITEM_Y, ATTR_ROW(22),
  757.               0);
  758.     window_fit(def_rule_panel);
  759.     window_fit(def_rule_popup);
  760.  
  761.     if (blackwhite)
  762.     tmpmag = mem_create(MAXSIZE, MAXSIZE, 1);
  763.     else
  764.     tmpmag = mem_create(MAXSIZE, MAXSIZE, 8);
  765.     mag = MAXSIZE / B;        /* initialize zoom pixrect & variables */
  766.     closeup = 0;
  767.     saved_mag_factor = mag;
  768.     side = B;
  769.  
  770.     if (blackwhite)
  771.     init_textures();        /* set up textures */
  772.     else
  773.     init_cmap();            /* set up colormap */
  774.  
  775. } /* init_scr */
  776.  
  777.  
  778. static int
  779. def_im_popup_proc()
  780. {
  781.     window_set(def_im_popup, WIN_SHOW, TRUE, 0);
  782. }
  783.  
  784.  
  785. void
  786. def_im_get_settings()
  787. {
  788.     save_in_image_dir = (int)panel_get_value(def_im_save_item);
  789.     save_images_compressed = 1 - (int)panel_get_value(def_im_compress_item);
  790.     strcpy(Image_dir, (char *)panel_get_value(def_im_imagedir_item));
  791.     auto_image_change = 1 - (int)panel_get_value(def_im_autochange_item);
  792.     use_2D_always = (int)panel_get_value(def_im_2Dalways_item);
  793. }    
  794.  
  795. static void
  796. def_im_done_proc()
  797. {
  798.     def_im_get_settings();
  799.     window_set(def_im_popup, WIN_SHOW, FALSE, 0);
  800. }
  801.  
  802.  
  803. static int
  804. def_rule_popup_proc()
  805. {
  806.     window_set(def_rule_popup, WIN_SHOW, TRUE, 0);
  807. }
  808.  
  809.  
  810. void
  811. def_rule_get_settings()
  812. {
  813.     save_in_LT_dir = (int)panel_get_value(def_rule_save_item);
  814.     save_LT_compressed = 1 - (int)panel_get_value(def_rule_compress_item);
  815.     strcpy(Table_dir, (char *)panel_get_value(def_rule_tabledir_item));
  816.     strcpy(Fcn_dir, (char *)panel_get_value(def_rule_fcndir_item));
  817.     auto_nhood_change = 1 - (int)panel_get_value(def_rule_autochange_item);
  818. }
  819.  
  820.  
  821. static void
  822. def_rule_done_proc()
  823. {
  824.     def_rule_get_settings();
  825.     window_set(def_rule_popup, WIN_SHOW, FALSE, 0);
  826. }
  827.  
  828.  
  829. static int
  830. def_cmap_popup_proc()
  831. {
  832.     /* window_loop(def_cmap_popup); */
  833.     window_set(def_cmap_popup, WIN_SHOW, TRUE, 0);
  834. }
  835.  
  836.  
  837. void
  838. def_cmap_get_settings()
  839. {
  840.     save_in_cmap_dir = (int)panel_get_value(def_cmap_save_item);
  841.     save_cmap_compressed = 1 - (int)panel_get_value(def_cmap_compress_item);
  842.     strcpy(Cmap_dir, (char *)panel_get_value(def_cmap_cmapdir_item));
  843. }
  844.  
  845.  
  846. static void
  847. def_cmap_done_proc()
  848. {
  849.     def_cmap_get_settings();
  850.     window_set(def_cmap_popup, WIN_SHOW, FALSE, 0);
  851. }
  852.  
  853.  
  854. static int
  855. def_CM_popup_proc()
  856. {
  857.     window_set(def_CM_popup, WIN_SHOW, TRUE, 0);
  858. }
  859.  
  860.  
  861. void
  862. def_CM_get_settings()
  863. {
  864.     strcpy(CM_hostname, (char *)panel_get_value(def_CM_host_item));
  865.     sscanf((char *)panel_get_value(def_CM_port_item), "%hd", &CM_port);
  866.     CM_delay = (int)panel_get_value(def_CM_rundelay_item);
  867.     use_FB = (int)panel_get(def_CM_display_item, PANEL_TOGGLE_VALUE, 0);
  868.     use_Sun_disp = (int)panel_get(def_CM_display_item, PANEL_TOGGLE_VALUE, 1);
  869.     strcpy(CM_image_dir, (char *)panel_get_value(def_CM_imagedir_item));
  870.     strcpy(CM_fcn_dir, (char *)panel_get_value(def_CM_fcndir_item));
  871.     strcpy(CM_LT_dir, (char *)panel_get_value(def_CM_LTdir_item));
  872.     if (use_CM) {
  873.     CM_set_displays();
  874.     CM_send_delay();
  875.     CM_send_dirs();
  876.     }
  877.     CM_zoom = (int)panel_get_value(def_CM_zoom_item);
  878.     CM_panx = (int)panel_get_value(def_CM_panx_item);
  879.     CM_pany = (int)panel_get_value(def_CM_pany_item);
  880. }
  881.     
  882.  
  883. static void
  884. def_CM_done_proc()
  885. {
  886.     def_CM_get_settings();
  887.     window_set(def_CM_popup, WIN_SHOW, FALSE, 0);
  888. }
  889.  
  890.  
  891. /*
  892.  * Call one of the routines from the "Image" submenu of the "Defaults menu
  893.  */
  894. static int
  895. defaults_image_menu_proc(m,mi)
  896. Menu m;
  897. Menu_item mi;
  898. {
  899.     int val;
  900.  
  901.     val = (int)menu_get(mi, MENU_VALUE);
  902.     switch (val) {
  903.       case 1:
  904.     toggle_save_in_image_dir_proc();
  905.     break;
  906.       case 2:
  907.     toggle_save_images_compressed();
  908.     break;
  909.       case 3:
  910.     set_image_dir();
  911.     break;
  912.       case 4:
  913.     toggle_auto_image_change_proc();
  914.     break;
  915.       default:
  916.     clear_msg();
  917.     show_msg("Invalid menu selection");
  918.     break;
  919.     }
  920. }
  921.  
  922.  
  923. /*
  924.  * Call one of the routines from the "Rules" submenu of the "Defaults" menu
  925.  */
  926. static int
  927. defaults_rule_menu_proc(m,mi)
  928. Menu m;
  929. Menu_item mi;
  930. {
  931.     int val;
  932.  
  933.     val = (int)menu_get(mi, MENU_VALUE);
  934.     switch (val) {
  935.       case 1:
  936.     toggle_save_in_LT_dir_proc();
  937.     break;
  938.       case 2:
  939.     toggle_save_LT_compressed();
  940.     break;
  941.       case 3:
  942.     set_table_dir();
  943.     break;
  944.       case 4:
  945.     set_fcn_dir();
  946.     break;
  947.       case 5:
  948.     toggle_auto_nhood_change_proc();
  949.     break;
  950.       default:
  951.     clear_msg();
  952.     show_msg("Invalid menu selection");
  953.     break;
  954.     }
  955. }
  956.  
  957.  
  958. /*
  959.  * "Cmap" submenu
  960.  */
  961. static int
  962. defaults_cmap_menu_proc(m,mi)
  963. Menu m;
  964. Menu_item mi;
  965. {
  966.     int val;
  967.  
  968.     val = (int)menu_get(mi, MENU_VALUE);
  969.     switch (val) {
  970.       case 1:
  971.     toggle_save_in_cmap_dir_proc();
  972.     break;
  973.       case 2:
  974.     set_cmap_dir();
  975.     break;
  976.       default:
  977.     clear_msg();
  978.     show_msg("Invalid menu selection");
  979.     break;
  980.     }
  981. }
  982.  
  983.  
  984.  
  985. /*
  986.  * "CM" submenu
  987.  */
  988. static int
  989. defaults_CM_menu_proc(m,mi)
  990. Menu m;
  991. Menu_item mi;
  992. {
  993.     int val;
  994.  
  995.     val = (int)menu_get(mi, MENU_VALUE);
  996.     switch (val) {
  997.       case 1:
  998.     CM_change_host();
  999.     break;
  1000.       case 2:
  1001.     CM_change_port();
  1002.     break;
  1003.       case 3:
  1004.     CM_change_delay_proc();
  1005.     break;
  1006.       case 4:
  1007.     FB_toggle();
  1008.     break;
  1009.       case 5:
  1010.     Sun_disp_toggle();
  1011.     break;
  1012.     /*
  1013.       case 6:
  1014.     CM_image_dir_proc();
  1015.     break;
  1016.       case 7:
  1017.     CM_fcn_dir_proc();
  1018.     break;
  1019.       case 8:
  1020.     CM_LT_dir_proc();
  1021.     break;
  1022.     */
  1023.       case 9:
  1024.     CM_set_zoom();
  1025.     break;
  1026.       case 10:
  1027.     /* CM_set_pan(); */
  1028.     break;
  1029.       default:
  1030.     clear_msg();
  1031.     show_msg("Invalid menu selection");
  1032.     break;
  1033.     }
  1034. }
  1035.  
  1036.  
  1037. /*
  1038.  * This gets called when the image-size changes, to reset a few vars
  1039.  */
  1040. change_scr()
  1041. {
  1042.     char tmp_str[80];
  1043.     
  1044.     mag = MAXSIZE / B;
  1045.     saved_mag_factor = mag;
  1046.     side = B;
  1047.     if (rule_shown) {
  1048.     /* strcpy(tmp_str, saved_rule_file);
  1049.     show_rule(tmp_str); */
  1050.     show_rule(saved_rule_file);
  1051.     }
  1052.     else
  1053.     clear_rule();
  1054.     panel_set_value(def_CM_zoom_item, CM_zoom);
  1055.     panel_set_value(def_CM_panx_item, B/2);
  1056.     panel_set_value(def_CM_pany_item, B/2);
  1057. }
  1058.  
  1059.  
  1060. void
  1061. set_CM_sliders()
  1062. {
  1063.     panel_set_value(def_CM_zoom_item, CM_zoom);
  1064.     panel_set_value(def_CM_panx_item, B/2);
  1065.     panel_set_value(def_CM_pany_item, B/2);
  1066. }
  1067.  
  1068.  
  1069. /*
  1070.  * Change the menus in the canvas, when the number of states gets changed
  1071.  */
  1072. change_canvas_menus()
  1073. {
  1074.     Menu_item item;
  1075.     int i;
  1076.  
  1077.     for (i = 0; i < S; i++) {
  1078.     item = menu_get(edit_menu, MENU_NTH_ITEM, i);
  1079.     menu_set(item, MENU_INACTIVE, FALSE, 0);
  1080.     }
  1081.     for (i = S; i < 16; i++) {
  1082.     item = menu_get(edit_menu, MENU_NTH_ITEM, i);
  1083.     menu_set(item, MENU_INACTIVE, TRUE, 0);
  1084.     }
  1085.     for (i=1; i <= L; i++) {
  1086.     item = menu_get(planeedit_menu, MENU_NTH_ITEM, i);
  1087.     menu_set(item, MENU_INACTIVE, FALSE, 0);
  1088.     }
  1089.     for (i = L+1; i <= 8; i++) {
  1090.     item = menu_get(planeedit_menu, MENU_NTH_ITEM, i);
  1091.     menu_set(item, MENU_INACTIVE, TRUE, 0);
  1092.     }
  1093. }
  1094.  
  1095. /*
  1096.  * Set up the cursor based on current mode
  1097.  */
  1098. static int
  1099. mode_proc(item, value, event)
  1100.     Panel_item item;
  1101.     int     value;
  1102.     Event  *event;
  1103. {
  1104.     screen_mode = value;
  1105.     switch (value) {            /* change cursor according to mode */
  1106.     case MODE_EDIT:
  1107.     cursor_set(cursor, CURSOR_CROSSHAIR_COLOR, curr_color,
  1108.            CURSOR_CROSSHAIR_OP, /* PIX_SRC, */ PIX_SRC ^ PIX_DST, 0);
  1109.     break;
  1110.     case MODE_PROBE:
  1111.     cursor_set(cursor, CURSOR_CROSSHAIR_COLOR, AMASK,
  1112.            CURSOR_CROSSHAIR_OP, PIX_SRC ^ PIX_DST, 0);
  1113.     break;
  1114.     case MODE_PLANEEDIT:
  1115.     cursor_set(cursor, CURSOR_CROSSHAIR_COLOR, curr_planemask,
  1116.            CURSOR_CROSSHAIR_OP, PIX_SRC ^ PIX_DST, 0);
  1117.     break;
  1118.     }
  1119.     window_set(canvas, WIN_CURSOR, cursor, 0);
  1120. }
  1121.  
  1122.  
  1123. /*
  1124.  * Set the "stop_on" variable according to teh current setting of the
  1125.  * switch in the control panel
  1126.  */
  1127. static int
  1128. stop_on_proc(item, value, event)
  1129.     Panel_item item;
  1130.     int     value;
  1131.     Event  *event;
  1132. {
  1133.     stop_on_mode = value;
  1134. }
  1135.  
  1136.  
  1137. /*
  1138.  * Set magnification
  1139.  */
  1140. set_mag(m)
  1141.     int     m;
  1142. {
  1143.     saved_mag_factor = m;
  1144.     pw_writebackground(pw, 0, 0, MAXSIZE, MAXSIZE, PIX_SRC);
  1145.     mag = m;
  1146.     display_image();
  1147.     if (B * mag < MAXSIZE) {
  1148.     pw_vector(pw, B * mag, 0, B * mag, B * mag, PIX_SRC, -1);
  1149.     pw_vector(pw, 0, B * mag, B * mag, B * mag, PIX_SRC, -1);
  1150.     }
  1151. } /* set_mag */
  1152.  
  1153.  
  1154.  
  1155. /*
  1156.  * Do necessary SunView stuff when plane mask is reset
  1157.  */
  1158. plane_reset_proc()
  1159. {
  1160.     int     m = AMASK;
  1161.  
  1162.     clear_msg();
  1163.     if (invalid_set_pressed())
  1164.     return;
  1165.     if (setting_sequence)
  1166.     add_sequence(plane_reset_proc);
  1167.     pw_putattributes(pw, &m);
  1168.     display_image();
  1169.     show_planes(AMASK);
  1170. }
  1171.  
  1172.  
  1173.  
  1174. /*
  1175.  * Set plane display-mask
  1176.  */
  1177. plane_display_proc()
  1178. {
  1179.     int     m;
  1180.     char    buf[BUFLEN];
  1181.     
  1182.     clear_msg();
  1183.     if (invalid_set_pressed())
  1184.     return;
  1185.     if (setting_sequence)
  1186.     add_sequence(plane_display_proc);
  1187.     get_msg("Display mask:", buf, BUFLEN, saved_display_mask);
  1188.     if (buf[0] == 0)
  1189.     return;
  1190.     strcpy(saved_display_mask, buf);
  1191.     if (sscanf(buf, "%x", &m) != 1) {
  1192.     show_msg("Illegal mask");
  1193.     return;
  1194.     }
  1195.     m &= AMASK;
  1196.     pw_writebackground(pw, 0, 0, MAXSIZE, MAXSIZE, PIX_SRC);
  1197.     pw_putattributes(pw, &m);
  1198.     display_image();
  1199.     show_planes(m);
  1200. }
  1201.  
  1202.  
  1203. /*
  1204.  * Quit the tool.  We have to be careful so that, if the user starts
  1205.  * to quit but then cancels, we won't detach from the CMFE if we're attached.
  1206.  */
  1207. quit_proc()
  1208. {
  1209.     int ret_val;
  1210.     
  1211.     clear_msg();
  1212.     if (invalid_set_pressed())
  1213.     return;
  1214.     ret_val = window_destroy(frame);
  1215.     if (ret_val) {
  1216.     if (use_CM)
  1217.         CM_disconnect();
  1218.     window_set(frame, FRAME_NO_CONFIRM, TRUE, 0);
  1219.     window_destroy(frame);
  1220.     }
  1221. }
  1222.  
  1223.  
  1224. /*
  1225.  * Save current image in a Sun rasterfile.  If in color mode, it supposedly
  1226.  * dumps the proper colormap into the rasterfile (this doesn't always
  1227.  * seem to work right, though, probably because of Sun's problems with
  1228.  * colormaps of length 256).  In B&W mode, the current textures and
  1229.  * magnification are used.
  1230.  */
  1231. isave_raster()
  1232. {
  1233.     State *ap;
  1234.     int ras_type = RT_STANDARD, x, y;
  1235.     colormap_t *colormap;
  1236.     Pixrect *pr;
  1237.     FILE *fp;
  1238.  
  1239.     ap = ca + B;
  1240.     clear_msg();
  1241.     if (invalid_set_pressed())
  1242.     return;
  1243.     if (setting_sequence)
  1244.     add_sequence(isave_raster);
  1245.     if (closeup) {
  1246.     show_msg("Doesn't work in closeup yet");
  1247.     return;
  1248.     }
  1249.     get_msg("Save raster file:", buf1, BUFLEN, saved_image_file);
  1250.     if (buf1[0] == NULL)
  1251.     return;
  1252.     if ((buf1[0] == '/') || (!strncmp(buf1, "./", 2)) || (!save_in_image_dir))
  1253.     ;
  1254.     else {
  1255.     strcpy(buf2, buf1);
  1256.     sprintf(buf1, "%s/%s", Image_dir, buf2);
  1257.     }
  1258.     if (expand_fname(buf1, buf1))
  1259.     return;
  1260.     strcpy(saved_image_file, buf1);
  1261.     if ((fp = fopen(buf1, "r")) != NULL) {
  1262.     get_msg("Overwrite file?", buf2, BUFLEN, "");
  1263.     if (buf2[0] != 'y') {
  1264.         show_msg("Save cancelled.");
  1265.         return;
  1266.     }
  1267.     fclose(fp);
  1268.     }
  1269.     if ((fp = fopen(buf1,"w")) == NULL) {
  1270.     show_msg("Could not open file");
  1271.     return;
  1272.     }
  1273.     if (blackwhite) {
  1274.     if ((pr = mem_create(B*mag, B*mag, 1)) == NULL) {
  1275.         show_msg("Couldn't create tmp pixrect");
  1276.         return;
  1277.     }
  1278.     colormap = NULL;
  1279.     }
  1280.     else {
  1281.     if ((pr = mem_create(B, B, 8)) == NULL) {
  1282.         show_msg("Couldn't create tmp pixrect");
  1283.         return;
  1284.     }
  1285.     if ((colormap = (colormap_t *)malloc(sizeof(colormap_t))) == NULL) {
  1286.         show_msg("Couldn't create colormap");
  1287.         return;
  1288.     }
  1289.     colormap->type = RMT_EQUAL_RGB;
  1290.     colormap->length = 256;
  1291.     colormap->map[0] = red;
  1292.     colormap->map[1] = green;
  1293.     colormap->map[2] = blue;
  1294.     }
  1295.     if ((!blackwhite) || (mag == 1)) {
  1296.     for (y=0; y < B; y++)
  1297.         for (x=0; x < B; x++) {
  1298.         pr_put(pr, x, y, *ap);
  1299.         ap++;
  1300.         }
  1301.     }
  1302.     else {
  1303.     pr_rop(pr, 0, 0, side*mag, side*mag, PIX_SRC, NULL, 0, 0);
  1304.     for (y=0; y < B; y++)
  1305.         for (x=0; x < B; x++) {
  1306.         if (color[*ap])
  1307.             pr_rop(pr, x*mag, y*mag, mag, mag, PIX_SRC,
  1308.                &textures_pr[color[*ap]], 0, 0);
  1309.         ap++;
  1310.         }
  1311.     }
  1312.         
  1313.     if (pr_dump(pr, fp, colormap, ras_type, FALSE))
  1314.     show_msg("Error trying to dump raster");
  1315.     else
  1316.     show_msg("Rasterfile written.");
  1317.     fclose(fp);
  1318.     free(pr);
  1319.     if (colormap)
  1320.     free(colormap);
  1321. }
  1322.         
  1323.     
  1324.  
  1325. /***** canvas event procedures *****/
  1326.  
  1327. /*
  1328.  * Main event procedure for the canvas
  1329.  */
  1330. static int
  1331. screen_event_proc(canvas, event)
  1332.     Canvas  canvas;
  1333.     Event  *event;
  1334. {
  1335.     int     x, y, k, a;
  1336.  
  1337.     pixel_to_cell(event_x(event), event_y(event), &x, &y);
  1338.     if (x >= B || y >= B) {
  1339.     clear_pos();
  1340.     clear_state();
  1341.     return;
  1342.     }
  1343.     k = event_id(event);
  1344.     if (!drawing) {
  1345.     switch (screen_mode) {
  1346.       case MODE_EDIT:
  1347.         edit_event(canvas, event, x, y, k);
  1348.         break;
  1349.       case MODE_PROBE:
  1350.         probe_event(canvas, event, x, y, k);
  1351.         break;
  1352.       case MODE_PLANEEDIT:
  1353.         planeedit_event(canvas, event, x, y, k);
  1354.         break;
  1355.     }
  1356.     }
  1357.     switch (k) {        /* actions common to all screen modes */
  1358.       case LOC_MOVE:
  1359.       case LOC_RGNENTER:
  1360.     show_pos(x, y);
  1361.     show_state(ca[(y * B) + ABASE + x]);
  1362.     break;
  1363.       case LOC_RGNEXIT:
  1364.     clear_pos();
  1365.     clear_state();
  1366.     break;
  1367.       default:
  1368.     break;
  1369.     }
  1370.     if (drawing)
  1371.     drawing_event(canvas, event, x, y, k);
  1372. }
  1373.  
  1374.  
  1375. /*
  1376.  * Event-proc when in edit-mode
  1377.  */
  1378. edit_event(canvas, event, x, y, k)
  1379.     Canvas  canvas;
  1380.     Event  *event;
  1381.     int     x, y, k;
  1382. {
  1383.     switch (k) {
  1384.     case LOC_MOVE:
  1385.     case LOC_RGNENTER:
  1386.     if ((int) window_get(canvas, WIN_EVENT_STATE, MS_LEFT))
  1387.         set_site(x, y, curr_color);
  1388.     else if ((int) window_get(canvas, WIN_EVENT_STATE, MS_MIDDLE))
  1389.         set_site(x, y, 0);
  1390.     break;
  1391.     case MS_LEFT:
  1392.     set_site(x, y, curr_color);
  1393.     break;
  1394.     case MS_MIDDLE:
  1395.     set_site(x, y, 0);
  1396.     break;
  1397.     case MS_RIGHT:
  1398.     if (function) return;
  1399.     menu_set((Menu_item) menu_get(edit_menu, MENU_NTH_ITEM, curr_color),
  1400.          MENU_BOXED, TRUE, 0);
  1401.     k = (int) menu_show(edit_menu, canvas, event, 0);
  1402.     menu_set((Menu_item) menu_get(edit_menu, MENU_NTH_ITEM, curr_color),
  1403.          MENU_BOXED, FALSE, 0);
  1404.     if (k != 0) {
  1405.         set_color(k);
  1406.     }
  1407.     break;
  1408.     default:
  1409.     if (is_state(k))
  1410.         set_color(to_state(k));
  1411.     break;
  1412.     }
  1413. }
  1414.  
  1415.  
  1416. /*
  1417.  * Event-proc for probe mode
  1418.  */
  1419. probe_event(canvas, event, x, y, k)
  1420.     Canvas  canvas;
  1421.     Event  *event;
  1422.     int     x, y, k;
  1423. {
  1424.     int     a;
  1425.  
  1426.     if (function)
  1427.     return;
  1428.     switch (k) {
  1429.     case MS_LEFT:
  1430.     if (event_is_down(event))
  1431.         show_next_state(x, y);
  1432.     break;
  1433.     case MS_RIGHT:
  1434.     if (use_CM) {
  1435.         clear_msg();
  1436.         show_msg("Not implement for CM yet");
  1437.         return;
  1438.     }
  1439.     if (event_is_down(event)) {
  1440.         show_next_state(x, y);
  1441.         k = (int) menu_show(probe_menu, canvas, event, 0);
  1442.         if (k != 0) {
  1443.         a = get_address(x, y);
  1444.         to_nhood(a, buf1);
  1445.         alter_nhood(buf1);
  1446.         }
  1447.     }
  1448.     break;
  1449.     }
  1450. }
  1451.  
  1452. /*
  1453.  * Event-proc for plane-edit mode
  1454.  */
  1455. planeedit_event(canvas, event, x, y, k)
  1456.     Canvas  canvas;
  1457.     Event  *event;
  1458.     int     x, y, k;
  1459. {
  1460.     switch (k) {
  1461.     case LOC_MOVE:
  1462.     case LOC_RGNENTER:
  1463.     if ((int) window_get(canvas, WIN_EVENT_STATE, MS_LEFT))
  1464.         set_site_bit(x, y, curr_planemask, TRUE);
  1465.     else if ((int) window_get(canvas, WIN_EVENT_STATE, MS_MIDDLE))
  1466.         set_site_bit(x, y, curr_planemask, FALSE);
  1467.     break;
  1468.     case MS_LEFT:
  1469.     set_site_bit(x, y, curr_planemask, TRUE);
  1470.     break;
  1471.     case MS_MIDDLE:
  1472.     set_site_bit(x, y, curr_planemask, FALSE);
  1473.     break;
  1474.     case MS_RIGHT:
  1475.     menu_set(menu_find(planeedit_menu, MENU_VALUE, curr_planemask, 0),
  1476.          MENU_BOXED, TRUE, 0);
  1477.     k = (int) menu_show(planeedit_menu, canvas, event, 0);
  1478.     menu_set(menu_find(planeedit_menu, MENU_VALUE, curr_planemask, 0),
  1479.          MENU_BOXED, FALSE, 0);
  1480.     if (k != 0) {
  1481.         set_planemask(k);
  1482.     }
  1483.     break;
  1484.     default:
  1485.     if (k >= ASCZ && k < ASCZ + L)
  1486.         set_planemask(1 << (k - ASCZ));
  1487.     break;
  1488.     }
  1489. }
  1490.  
  1491.  
  1492. /*
  1493.  * Event-proc when user is drawing a line or circle
  1494.  */
  1495. drawing_event(canvas, event, x, y, k)
  1496.     Canvas  canvas;
  1497.     Event  *event;
  1498.     int     x, y, k;
  1499. {
  1500.     int left_down;
  1501.     static int
  1502.     col, row, start_row, start_col, line_x, line_y,
  1503.     center_x, center_y;
  1504.  
  1505.     left_down = 0;
  1506.     switch (k) {
  1507.     /* case LOC_MOVE: */
  1508.     case LOC_RGNENTER:
  1509.     if ((int) window_get(canvas, WIN_EVENT_STATE, MS_LEFT))
  1510.         left_down = 1;
  1511.     else if ((int) window_get(canvas, WIN_EVENT_STATE, MS_MIDDLE)) {
  1512.         drawing = 0;
  1513.         clear_msg();
  1514.         show_msg("Aborted");
  1515.         return;
  1516.     }
  1517.     break;
  1518.     case MS_LEFT:
  1519.     if event_is_down(event) {
  1520.         left_down = 1;
  1521.     }
  1522.     else {
  1523.         if (drawing == DRAWING_DONE) {
  1524.         drawing = 0;
  1525.         return;
  1526.         }
  1527.     }
  1528.     break;
  1529.     case MS_MIDDLE:
  1530.     drawing = 0;
  1531.     clear_msg();
  1532.     show_msg("Aborted");
  1533.     return;
  1534.     break;
  1535.     }
  1536.     if (left_down) {
  1537.     switch (drawing) {
  1538.       case HORIZ_LINE:
  1539.         clear_msg();
  1540.         show_msg("Click left button at end col");
  1541.         drawing = HORIZ_END;
  1542.         start_col = x;
  1543.         row = y;
  1544.         set_site(x, y, curr_color);
  1545.         display_site(x, y, curr_color);
  1546.         break;
  1547.       case HORIZ_END:
  1548.         draw_horizontal_line(row, start_col, x, curr_color);
  1549.         clear_msg();
  1550.         show_msg("Done.");
  1551.         drawing = DRAWING_DONE;
  1552.         break;
  1553.       case VERT_LINE:
  1554.         clear_msg();
  1555.         show_msg("Click left button at end row");
  1556.         drawing = VERT_END;
  1557.         col = x;
  1558.         start_row = y;
  1559.         set_site(x, y, curr_color);
  1560.         display_site(x, y, curr_color);
  1561.         break;
  1562.       case VERT_END:
  1563.         draw_vertical_line(col, start_row, y, curr_color);
  1564.         clear_msg();
  1565.         show_msg("Done.");
  1566.         drawing = DRAWING_DONE;
  1567.         break;
  1568.       case ARB_LINE:
  1569.         clear_msg();
  1570.         show_msg("Click left button at other end");
  1571.         line_x = x;
  1572.         line_y = y;
  1573.         drawing = ARB_END;
  1574.         set_site(line_x, line_y, curr_color);
  1575.         display_site(line_x, line_y, curr_color);
  1576.         break;
  1577.       case ARB_END:
  1578.         draw_arbitrary_line(line_x, line_y, x, y, curr_color);
  1579.         clear_msg();
  1580.         show_msg("Done.");
  1581.         drawing = DRAWING_DONE;
  1582.         return;
  1583.       case HOLLOW_CIRC:
  1584.         drawing = HOLLOW_EDGE;
  1585.         center_x = x;
  1586.         center_y = y;
  1587.         clear_msg();
  1588.         show_msg("Click left button on edge");
  1589.         show_msg("of circle");
  1590.         set_site(center_x, center_y, curr_color);
  1591.         display_site(center_x, center_y, curr_color);
  1592.         break;
  1593.       case HOLLOW_EDGE:
  1594.         draw_hollow_circ(center_x, center_y, x, y, curr_color);
  1595.         clear_msg();
  1596.         show_msg("Done.");
  1597.         drawing = DRAWING_DONE;
  1598.         return;
  1599.       case SHADED_CIRC:
  1600.         drawing = SHADED_EDGE;
  1601.         center_x = x;
  1602.         center_y = y;
  1603.         clear_msg();
  1604.         show_msg("Click left button on edge");
  1605.         show_msg("of circle");
  1606.         set_site(center_x, center_y, curr_color);
  1607.         display_site(center_x, center_y, curr_color);
  1608.         break;
  1609.       case SHADED_EDGE:
  1610.         draw_shaded_circ(center_x, center_y, x, y, saved_xinc,
  1611.                 saved_yinc, curr_color);
  1612.         clear_msg();
  1613.         show_msg("Done.");
  1614.         drawing = DRAWING_DONE;
  1615.         return;
  1616.     }
  1617.     }
  1618. }
  1619.  
  1620.  
  1621. /***** general notify & event procedures *****/
  1622.  
  1623. /*
  1624.  * Pop up menu if right button, call top item if left, and call previous
  1625.  * item if middle button.
  1626.  */
  1627. static int
  1628. button_event_proc(item, event)
  1629.     Panel_item item;
  1630.     Event  *event;
  1631. {
  1632.     Menu_item m_item;
  1633.     func_ptr item_action_proc;
  1634.  
  1635.     if (((event_id(event) == MS_RIGHT) || (event_id(event) == MS_MIDDLE)) &&
  1636.     (event_is_down(event))) {
  1637.     def_im_get_settings();
  1638.     def_rule_get_settings();
  1639.     def_cmap_get_settings();
  1640.     /* def_CM_get_settings(); */
  1641.     }
  1642.     
  1643.     if (event_id(event) == MS_RIGHT && event_is_down(event))
  1644.     menu_show((Menu) panel_get(item, PANEL_CLIENT_DATA), panel, event, 0);
  1645.     /* else if ((event_id(event) == MS_MIDDLE) && event_is_down(event) &&
  1646.          (item != defaults_button)) { */
  1647.     else if ((event_id(event) == MS_MIDDLE) && event_is_down(event)) {
  1648.     m_item = menu_get((Menu) panel_get(item, PANEL_CLIENT_DATA),
  1649.             MENU_SELECTED_ITEM);
  1650.     if (((char *)m_item) == NULL) {
  1651.         clear_msg();
  1652.         show_msg("no default menu selection found");
  1653.         return;
  1654.     }
  1655.     item_action_proc = (func_ptr)(menu_get(m_item, MENU_VALUE));
  1656.     if (item_action_proc == NULL) {
  1657.         clear_msg();
  1658.         show_msg("No default menu selection found");
  1659.         return;
  1660.     }
  1661.     item_action_proc();
  1662.     }
  1663.     else
  1664.     panel_default_handle_event(item, event);
  1665. }
  1666.  
  1667.  
  1668. /*
  1669.  * Call routine from menu
  1670.  */
  1671. static int
  1672. menu_notify_proc(m, mi)
  1673.     Menu    m;
  1674.     Menu_item mi;
  1675. {
  1676.     ((int (*) ()) menu_get(mi, MENU_VALUE)) ();
  1677. }
  1678.  
  1679.  
  1680. /*
  1681.  * Call the first routine in a menu
  1682.  */
  1683. static int
  1684. do_first_item_proc(item, event)
  1685.     Panel_item item;
  1686.     Event  *event;
  1687. {
  1688.     Menu    menu = (Menu) panel_get(item, PANEL_CLIENT_DATA);
  1689.     Menu_item mi = menu_get(menu, MENU_NTH_ITEM, 1);
  1690.     def_im_get_settings();
  1691.     def_rule_get_settings();
  1692.     def_cmap_get_settings();
  1693.     /* def_CM_get_settings(); */
  1694.     ((int (*) ()) menu_get(mi, MENU_VALUE)) ();
  1695. }
  1696.  
  1697.  
  1698. /***** display-related utilities *****/
  1699.  
  1700. void
  1701. command_loop()
  1702. {                    /* wait for commands and process them
  1703.                      * as they come */
  1704.     window_main_loop(frame);        /* handled by the SunView Notifier */
  1705. }
  1706.  
  1707.  
  1708. set_run_mode()
  1709. {                    /* disable panel & canvas input */
  1710.  
  1711.     frame_mask = *((Inputmask *) window_get(frame, WIN_PICK_INPUT_MASK));
  1712.     window_set(frame, WIN_CONSUME_PICK_EVENT, WIN_NO_EVENTS, 0);
  1713.     panel_mask = *((Inputmask *) window_get(panel, WIN_PICK_INPUT_MASK));
  1714.     window_set(panel, WIN_CONSUME_PICK_EVENT, MS_LEFT, 0);
  1715.     canvas_mask = *((Inputmask *) window_get(canvas, WIN_PICK_INPUT_MASK));
  1716.     window_set(canvas, WIN_CONSUME_PICK_EVENT, MS_LEFT, 0);
  1717. }
  1718.  
  1719.  
  1720. unset_run_mode()
  1721. {                    /* re-enable panel & canvas input */
  1722.     window_set(frame, WIN_PICK_INPUT_MASK, &frame_mask, 0);
  1723.     window_set(panel, WIN_PICK_INPUT_MASK, &panel_mask, 0);
  1724.     window_set(canvas, WIN_PICK_INPUT_MASK, &canvas_mask, 0);
  1725. }
  1726.  
  1727.  
  1728. check_button()
  1729. {                    /* return TRUE iff the left button has
  1730.                      * been pressed */
  1731.     int     err, button1, button2;
  1732.     int fd1, ff1, fd2, ff2;
  1733.     Event   event;
  1734.  
  1735.     /* set non-blocking mode in panel */
  1736.     fd1 = (int) window_get(panel, WIN_FD);
  1737.     ff1 = fcntl(fd1, F_GETFL, 0);
  1738.     fcntl(fd1, F_SETFL, FNDELAY);
  1739.     /* non-blocking mode in canvas */
  1740.     fd2 = (int) window_get(canvas, WIN_FD);
  1741.     ff2 = fcntl(fd2, F_GETFL, 0);
  1742.     fcntl(fd2, F_SETFL, FNDELAY);
  1743.     do {
  1744.     err = window_read_event(panel, &event);
  1745.     button1 = ((err == 0) && (event_is_up(&event)) &&
  1746.           (event_id(&event) == MS_LEFT));
  1747.     } while ((err == 0) && !button1);
  1748.     do {
  1749.     err = window_read_event(canvas, &event);
  1750.     button2 = ((err == 0) && (event_is_up(&event)) &&
  1751.           (event_id(&event) == MS_LEFT));
  1752.     } while ((err == 0) && !button2);
  1753.     /* if no events remain, err will equal -1 */
  1754.  
  1755.     /* Restore blocking mode in panel and canvas */
  1756.     fcntl(fd1, F_SETFL, ff1);
  1757.     fcntl(fd2, F_SETFL, ff2);
  1758.     /* if button was pressed in either panel or canvas, return 1 */
  1759.     return (button1 | button2);
  1760. }
  1761.  
  1762.  
  1763. /* The following routines update various control panel items... */
  1764. /* Most are self-explanatory. */
  1765. show_time(stime)
  1766. {
  1767.     sprintf(buf1, "%-5d ", stime);
  1768.     panel_set(pan_time, PANEL_LABEL_STRING, buf1, 0);
  1769. }
  1770.  
  1771.  
  1772. show_pos(x, y)
  1773.     int     x, y;
  1774. {
  1775.     sprintf(buf1, "(%3d,%3d)", x, y);
  1776.     panel_set(pan_pos, PANEL_LABEL_STRING, buf1, 0);
  1777. }
  1778.  
  1779.  
  1780. clear_pos()
  1781. {
  1782.     panel_set(pan_pos, PANEL_LABEL_STRING, "         ", 0);
  1783. }
  1784.  
  1785.  
  1786. show_state(s)
  1787.     State   s;
  1788. {
  1789.     buf1[0] = to_char(s/16);
  1790.     buf1[1] = to_char(s%16);
  1791.     buf1[2] = NULL;
  1792.     panel_set(pan_state, PANEL_LABEL_STRING, buf1, 0);
  1793. }
  1794.  
  1795.  
  1796. clear_state()
  1797. {
  1798.     panel_set(pan_state, PANEL_LABEL_STRING, "   ", 0);
  1799. }
  1800.  
  1801.  
  1802. show_planes(mask)            /* show which bitplanes are currently
  1803.                      * displayed */
  1804.     int     mask;
  1805. {
  1806.     char    str[6];
  1807.     if (mask == AMASK)
  1808.     strcpy(str, "ALL");
  1809.     else
  1810.     sprintf(str, "%X", mask);
  1811.     panel_set(pan_planes, PANEL_LABEL_STRING, str, 0);
  1812. }
  1813.  
  1814.  
  1815. show_rule(str)
  1816. char   *str;
  1817. {
  1818.     char lbl[128], nhstr[10], istr[10];
  1819.  
  1820.     sprintf(istr, "b%d", B);
  1821.     switch(NHOOD) {
  1822.       case NH_MOORE:
  1823.     sprintf(nhstr, "m%d", S);
  1824.     break;
  1825.       case NH_MARG:
  1826.     sprintf(nhstr, "M%d", S);
  1827.     break;
  1828.       case NH_VONN:
  1829.     sprintf(nhstr, "v%d", S);
  1830.     break;
  1831.       case NH_LIN:
  1832.     sprintf(nhstr, "l%dr%d", S, R);
  1833.     break;
  1834.     }
  1835.     if (str == (char *)0)
  1836.     sprintf(lbl, "Cellsim 2.5: %s %s   rule: %s", nhstr, istr,
  1837.         saved_rule_file);
  1838.     else
  1839.     sprintf(lbl, "Cellsim 2.5: %s %s   rule: %s", nhstr, istr, str);
  1840.     window_set(frame, FRAME_LABEL, lbl, 0);
  1841.     rule_shown = 1;
  1842. }
  1843.  
  1844.  
  1845. clear_rule()
  1846. {
  1847.     char lbl[80], nhstr[10], istr[10];
  1848.  
  1849.     sprintf(istr, "b%d", B);
  1850.     switch(NHOOD) {
  1851.       case NH_MOORE:
  1852.     sprintf(nhstr, "m%d", S);
  1853.     break;
  1854.       case NH_MARG:
  1855.     sprintf(nhstr, "M%d", S);
  1856.     break;
  1857.       case NH_VONN:
  1858.     sprintf(nhstr, "v%d", S);
  1859.     break;
  1860.       case NH_LIN:
  1861.     sprintf(nhstr, "l%dr%d", S, R);
  1862.     break;
  1863.     }
  1864.     sprintf(lbl, "Cellsim 2.5: %s %s", nhstr, istr);
  1865.     window_set(frame, FRAME_LABEL, lbl, 0);
  1866.     rule_shown = 0;
  1867. }
  1868.  
  1869.  
  1870. show_msg(str)                /* display string in message area */
  1871.     char   *str;
  1872. {
  1873.     panel_set(pan_msg[msg_line++], PANEL_LABEL_STRING, str, 0);
  1874.     if (msg_line == NUM_MSGS)
  1875.     msg_line = 0;
  1876. }
  1877.  
  1878.  
  1879. get_msg(prompt, str, len, default_val)    /* input message in message area */
  1880.     char   *prompt, *str, *default_val;
  1881.     int     len;
  1882. {
  1883.     int i, j;
  1884.     
  1885.     show_msg(prompt);
  1886.     panel_set(pop_input,
  1887.           PANEL_VALUE, default_val, 0);
  1888.     window_set(popup, WIN_X, 0,
  1889.     WIN_Y, (int) panel_get(pan_msg[msg_line], PANEL_ITEM_Y) + pan_tmargin, 0);
  1890.     window_loop(popup);
  1891.     strncpy(str, (char *) panel_get_value(pop_input), len);
  1892.     str[len] = '\0';
  1893.     i = 0;
  1894.     j = 0;
  1895.     while ((str[i] == ' ') || (str[i] == '\t'))
  1896.     i++;
  1897.     while (str[i] != '\0')
  1898.     str[j++] = str[i++];
  1899.     str[j] = '\0';
  1900.     show_msg(str);
  1901. }
  1902.  
  1903.  
  1904. static Panel_setting
  1905. return_proc()
  1906. {                    /* return procedure for popup window
  1907.                      * loop */
  1908.     window_return(NULL);
  1909. }
  1910.  
  1911.  
  1912. int
  1913. get_num(prompt, n, nmin, nmax, default_val)  /* input (decimal or hex)
  1914.                           * integer in message area */
  1915.     char   *prompt;
  1916.     int    *n, nmin, nmax, default_val;
  1917. {
  1918.     int     err;
  1919.     char    buf[BUFLEN], numbuf[20];
  1920.  
  1921.     if (default_val != INTUNDEF)
  1922.     sprintf(numbuf,"%d",default_val);
  1923.     else
  1924.     numbuf[0] = '\0';
  1925.     get_msg(prompt, buf, BUFLEN, numbuf);
  1926.     if (buf[0] == NULL)
  1927.     return (1);
  1928.     if ((!strncmp(buf, "0x", 2)) || (!strncmp(buf, "0X", 2)))
  1929.     err = sscanf(&buf[2], "%x", n);
  1930.     else
  1931.     err = sscanf(buf, "%d", n);
  1932.     if (err != 1 || *n < nmin || *n > nmax) {
  1933.     show_msg("Illegal value");
  1934.     return (1);
  1935.     } else
  1936.     return (0);
  1937. }
  1938.  
  1939.  
  1940. /* Get 2 integers in message area */
  1941. int
  1942. get_2num(prompt, n1, n2, n1min, n1max, n2min, n2max, def1, def2)
  1943.     char   *prompt;
  1944.     int    *n1, *n2, n1min, n1max, n2min, n2max, def1, def2;
  1945. {
  1946.     int     err;
  1947.     char    buf[BUFLEN], numbuf[20], numbuf2[20];
  1948.  
  1949.     if ((def1 != INTUNDEF) && (def2 != INTUNDEF))
  1950.     sprintf(numbuf,"%d %d", def1, def2);
  1951.     else
  1952.     numbuf[0] = '\0';
  1953.     get_msg(prompt, buf, BUFLEN, numbuf);
  1954.     if (buf[0] == NULL)
  1955.     return (1);
  1956.     err = sscanf(buf, "%s %s", numbuf, numbuf2);
  1957.     if (err != 2) {
  1958.     show_msg("Not enough parameters entered");
  1959.     return 1;
  1960.     }
  1961.     if ((!strncmp(numbuf, "0x", 2)) || (!strncmp(numbuf, "0X", 2)))
  1962.     err = sscanf(&numbuf[2], "%x", n1);
  1963.     else
  1964.     err = sscanf(numbuf, "%d", n1);
  1965.     if (err != 1 || *n1 < n1min || *n1 > n1max) {
  1966.     show_msg("Illegal value");
  1967.     return (1);
  1968.     }
  1969.     if ((!strncmp(numbuf2, "0x", 2)) || (!strncmp(numbuf2, "0X", 2)))
  1970.     err = sscanf(&numbuf2[2], "%x", n2);
  1971.     else
  1972.     err = sscanf(numbuf2, "%d", n2);
  1973.     if (err != 1 || *n2 < n2min || *n2 > n2max) {
  1974.     show_msg("Illegal value");
  1975.     return (1);
  1976.     }
  1977.     return 0;
  1978. }
  1979.  
  1980.  
  1981. clear_msg()
  1982. {                    /* clear message area */
  1983.     int     i;
  1984.     for (i = 0; i < NUM_MSGS; i++)
  1985.     panel_set(pan_msg[i], PANEL_LABEL_STRING, "", 0);
  1986.     msg_line = 0;
  1987. }
  1988.  
  1989.  
  1990. set_color(col)                /* set current insertion color for edit
  1991.                      * mode */
  1992.     int     col;
  1993. {
  1994.     static int odd=1;
  1995.     static int prev;
  1996.  
  1997.     if (function) {
  1998.     odd = 1-odd;
  1999.     if (!odd) {
  2000.         prev = col;
  2001.         return;
  2002.     }
  2003.     }
  2004.     else
  2005.     prev = 0;
  2006.     curr_color = col + 16*prev;
  2007.     clear_msg();
  2008.     sprintf(buf1,"current color = %02x\n",col + 16*prev);
  2009.     show_msg(buf1);
  2010.     cursor_set(cursor, CURSOR_CROSSHAIR_COLOR, col + 16*prev, 0);
  2011.     window_set(canvas, WIN_CURSOR, cursor, 0);
  2012. }
  2013.  
  2014.  
  2015. and_color(mask)   /* 'AND' the current color with the new state-mask */
  2016. short mask;
  2017. {
  2018.     set_color(curr_color & (int)mask);
  2019. }
  2020.  
  2021.  
  2022. set_planemask(m)            /* set current edit planemask for plane
  2023.                      * edit mode */
  2024.     int     m;
  2025. {
  2026.     curr_planemask = m;
  2027.     cursor_set(cursor, CURSOR_CROSSHAIR_COLOR, m, 0);
  2028.     window_set(canvas, WIN_CURSOR, cursor, 0);
  2029. }
  2030.  
  2031.  
  2032. and_planemask(mask)
  2033. short mask;
  2034. {
  2035.     set_planemask(curr_planemask & (int)mask);
  2036. }
  2037.  
  2038.  
  2039. set_site(x, y, value)            /* set given ca site to given value */
  2040.     int     x, y, value;
  2041. {
  2042.     ca[(y * B) + ABASE + x] = value;
  2043.     display_site(x, y, value);
  2044.     show_state(value);
  2045. }
  2046.  
  2047.  
  2048. set_site_bit(x, y, mask, on)    /* set/unset given bit in given ca site */
  2049.     int     x, y, mask, on;
  2050. {
  2051.     int     value;
  2052.     if (on)
  2053.     value = ca[(y * B) + ABASE + x] | mask;
  2054.     else
  2055.     value = ca[(y * B) + ABASE + x] & ~mask;
  2056.     set_site(x, y, value);
  2057. }
  2058.  
  2059.  
  2060. mark_site(x, y)                /* mark given site in ca display */
  2061.     int     x, y;
  2062. {
  2063.     int     x0, y0, x1, y1;
  2064.     x0 = (x - xstart) * mag;
  2065.     y0 = (y - ystart) * mag;
  2066.     x1 = x0 + mag - 1;
  2067.     y1 = y0 + mag - 1;
  2068.     display_site(x, y, 0);        /* clear site */
  2069.     pw_vector(pw, x0, y0, x1, y1, PIX_SRC, -1);
  2070.     pw_vector(pw, x0, y1, x1, y0, PIX_SRC, -1);
  2071. }
  2072.  
  2073.  
  2074. display_site(x, y, value)        /* show given value at given site in ca
  2075.                      * display */
  2076.     int     x, y;
  2077.     State   value;
  2078. {
  2079.     if (blackwhite)
  2080.     pw_rop(pw, (x-xstart) * mag, (y-ystart) * mag,
  2081.            mag, mag, PIX_SRC, &textures_pr[color[value]], 0, 0);
  2082.     else
  2083.     pw_write(pw, (x - xstart) * mag, (y - ystart) * mag,
  2084.          mag, mag, PIX_COLOR(value) | PIX_SRC, NULL, 0, 0);
  2085. }
  2086.  
  2087.  
  2088. display_image()
  2089. {                    /* display entire ca array */
  2090.     unsigned char *cptr, *tptr;
  2091.     int x,y;
  2092.  
  2093.     pr_rop(tmpmag,0,0,B*mag,B*mag,PIX_SRC,NULL,0,0);
  2094.     if (blackwhite) {
  2095.     if (mag == 1) {
  2096.         cptr = ca;
  2097.         tptr = (unsigned char *)(mpr_d(tmpmag)->md_image);
  2098.         for (y=0; y<B; y++)
  2099.         for (x=0; x<B; x++)
  2100.             /* *(tptr++) = (*(cptr++) != 0); */
  2101.             if (*(cptr++)) pr_put(tmpmag,x,y,1);
  2102.         pw_write(pw,0,0,B*mag,B*mag,PIX_SRC,tmpmag,0,1);
  2103.     }
  2104.     else
  2105.         magnify_image(mag,side,xstart,ystart);
  2106.     }
  2107.     else {
  2108.     if (mag == 1)
  2109.         pw_write(pw, 0, 0, B * mag, B * mag, PIX_SRC, ca_handle, 0, 1);
  2110.     else
  2111.         magnify_image(mag, side, xstart, ystart);
  2112.     }
  2113. }
  2114.  
  2115.  
  2116. pixel_to_cell(xp, yp, xc, yc)        /* convert from pixel coords. to cell
  2117.                      * coords. */
  2118.     int     xp, yp, *xc, *yc;
  2119. {
  2120.     *xc = (xp / mag);
  2121.     *yc = (yp / mag);
  2122.     if ((mag != 1) && closeup) {
  2123.     *xc += xstart;
  2124.     *yc += ystart;
  2125.     }
  2126. }
  2127.  
  2128.  
  2129. init_cmap()
  2130. {                    /* initialize color map */
  2131.     int     k;
  2132.  
  2133.  
  2134.     color[0] = 0x000000;        /* black */
  2135.  
  2136.     color[1] = 0xFF0000;        /* red */
  2137.     color[2] = 0x0000FF;        /* blue */
  2138.     color[3] = 0xFF00FF;        /* magenta */
  2139.     color[4] = 0x00D000;        /* green */
  2140.     color[5] = 0xFFFF00;        /* yellow */
  2141.     color[6] = 0x00D0FF;        /* cyan */
  2142.     color[7] = 0xC0C0C0;        /* light gray */
  2143.     color[8] = 0x808080;        /* dark gray */
  2144.     color[9] = 0xFFC0C0;        /* light red */
  2145.     color[10] = 0xC0C0FF;        /* light blue */
  2146.     color[11] = 0xFFC0FF;        /* light magenta */
  2147.     color[12] = 0xC0FFC0;        /* light green */
  2148.     color[13] = 0xFFFFC0;        /* light yellow */
  2149.     color[14] = 0xC0FFFF;        /* light cyan */
  2150.     color[15] = 0xFFFFFF;        /* white */
  2151.  
  2152.     /* greyscale above 16 for now */
  2153.     for (k=16; k<256; k++)
  2154.     color[k] = k + k*256 + k*65536;
  2155.     color[255] = 0xFFFFFF;
  2156.     
  2157.     for (k = 0; k < 256; k++)
  2158.     set_cmap_entry(k, color[k]);
  2159.  
  2160.     sprintf(cmap_name, "cell%d", getpid());
  2161.     pw_setcmsname(pw, cmap_name);
  2162.     pw_putcolormap(pw, 0, 256, red, green, blue);
  2163.     
  2164.     sprintf(cmap_name2, "cell2%d", getpid());
  2165.     pw_setcmsname(window_pw, cmap_name2);
  2166.     pw_putcolormap(window_pw, 0, 256, red, green, blue);
  2167.     
  2168.     sprintf(cmap_name3, "cell3%d", getpid());
  2169.     pw_setcmsname(panel_pw, cmap_name3);
  2170.     pw_putcolormap(panel_pw, 0, 256, red, green, blue);
  2171.     
  2172.  
  2173. } /* init_cmap() */
  2174.  
  2175.  
  2176.  
  2177. init_textures()
  2178. {
  2179.     int i,j,j1,k,sz;
  2180.     char fname[40];
  2181.     struct mpr_data data[CMAPLEN];
  2182.  
  2183.     sz = MAXSIZE/B + 1;
  2184.     for (k=0; k < CMAPLEN; k++)
  2185.     color[k] = k%16;
  2186. }
  2187.  
  2188.     
  2189. set_cmap_entry(n, c)
  2190.     int     n, c;
  2191. {
  2192.     color[n] = c;
  2193.     red[n] = (c >> (2 * CLEN)) & CMASK;
  2194.     green[n] = (c >> CLEN) & CMASK;
  2195.     blue[n] = c & CMASK;
  2196. }
  2197.  
  2198.  
  2199. set_rgb_arrays(r,g,b)
  2200. unsigned char *r,*g,*b;
  2201. {
  2202.     int i;
  2203.  
  2204.     for (i=0; i<256; i++) {
  2205.     r[i] = (color[i] >> (2 * CLEN)) & CMASK;
  2206.     g[i] = (color[i] >> CLEN) & CMASK;
  2207.     b[i] = color[i] & CMASK;
  2208.     }
  2209. }
  2210.  
  2211.  
  2212. cmap_alter()
  2213. {                    /* alter a colormap entry */
  2214.     int     e, c;
  2215.     char    buf2[6];
  2216.     
  2217.     clear_msg();
  2218.     if (invalid_set_pressed())
  2219.     return;
  2220.     if (setting_sequence)
  2221.     add_sequence(cmap_alter);
  2222.     if (get_num("Change color of entry:", &e, 0, CMAPLEN - 1, saved_cmap_entry))
  2223.     return;
  2224.     saved_cmap_entry = e;
  2225.     sprintf(buf1, "Currently %06X; change to:", color[e]);
  2226.     get_msg(buf1, buf2, 6, "");
  2227.     if (buf2[0] == NULL)
  2228.     return;
  2229.     if (sscanf(buf2, "%6x", &c) != 1) {
  2230.     show_msg("Illegal value");
  2231.     return;
  2232.     }
  2233.     if (e == 0) {
  2234.     if (c == color[255]) {
  2235.         clear_msg();
  2236.         show_msg("Invalid -- cannot set entry 0");
  2237.         show_msg("to same color as entry 255");
  2238.         return;
  2239.     }
  2240.     }
  2241.     if (e == 255) {
  2242.     if (c == color[0]) {
  2243.         clear_msg();
  2244.         show_msg("Invalid -- cannot set entry 255");
  2245.         show_msg("to same color as entry 0");
  2246.         return;
  2247.     }
  2248.     }
  2249.     set_cmap_entry(e, c);
  2250.     if (blackwhite)
  2251.     display_image();
  2252.     else {
  2253.     pw_setcmsname(pw, cmap_name);
  2254.     pw_putcolormap(pw, 0, 256, red, green, blue);
  2255.     pw_setcmsname(window_pw, cmap_name2);
  2256.     pw_putcolormap(window_pw, 0, 256, red, green, blue);
  2257.     pw_setcmsname(panel_pw, cmap_name3);
  2258.     pw_putcolormap(panel_pw, 0, 256, red, green, blue);
  2259.     }
  2260. }
  2261.  
  2262.  
  2263.  
  2264. cmap_save_proc()
  2265. {
  2266.     if (invalid_set_pressed())
  2267.     return;
  2268.     if (setting_sequence)
  2269.     add_sequence(cmap_save_proc);
  2270.     if (save_cmap_compressed)
  2271.     cmap_save_compressed();
  2272.     else
  2273.     cmap_save();
  2274. }
  2275.  
  2276.  
  2277. cmap_save()
  2278. {                    /* save current colormap */
  2279.     FILE   *fp;
  2280.  
  2281.     /* write out array */
  2282.  
  2283.     clear_msg();
  2284.     if (invalid_set_pressed())
  2285.     return;
  2286.     if (setting_sequence)
  2287.     add_sequence(cmap_save);
  2288.     get_msg("Save color file:", buf1, BUFLEN, saved_cmap_file);
  2289.     if (buf1[0] == NULL) {
  2290.     show_msg("");
  2291.     return;
  2292.     }
  2293.     if ((buf1[0] == '/') || (!strncmp(buf1, "./", 2)) || (!strncmp(buf1, "../", 3)) || (!save_in_cmap_dir))
  2294.     ;
  2295.     else {
  2296.     strcpy(buf2, buf1);
  2297.     sprintf(buf1, "%s/%s", Cmap_dir, buf2);
  2298.     }
  2299.     if (expand_fname(buf1, buf1))
  2300.     return;
  2301.     strcpy(saved_cmap_file, buf1);
  2302.     if ((fp = fopen(buf1, "r")) != NULL) {
  2303.     if (!confirm_overwrite()) {
  2304.         fclose(fp);
  2305.         return;
  2306.     }
  2307.     }
  2308.     fclose(fp);
  2309.     fp = fopen(buf1, "w");
  2310.     fwrite(color, sizeof(*color), CMAPLEN, fp);
  2311.     fclose(fp);
  2312.     strcat(buf1, " saved");
  2313.     show_msg(buf1);
  2314. }
  2315.  
  2316.  
  2317. cmap_save_compressed()
  2318. {
  2319.     FILE *fp;
  2320.     int err;
  2321.  
  2322.     clear_msg();
  2323.     get_msg("Save cmap file:", buf1, BUFLEN, saved_cmap_file);
  2324.     if (buf1[0] == NULL) {
  2325.     show_msg("");
  2326.     return;
  2327.     }
  2328.     if ((buf1[0] == '/') || (!strncmp(buf1, "./", 2)) || (!strncmp(buf1, "../", 3)) || (!save_in_cmap_dir))
  2329.     ;
  2330.     else {
  2331.     strcpy(buf2, buf1);
  2332.     sprintf(buf1, "%s/%s", Cmap_dir, buf2);
  2333.     }
  2334.     if (expand_fname(buf1, buf1))
  2335.     return;
  2336.     if (strcmp(&buf1[strlen(buf1)-2], ".Z"))
  2337.     strcat(buf1, ".Z");
  2338.     strcpy(saved_cmap_file, buf1);
  2339.     if ((fp = fopen(buf1, "r")) != NULL) {
  2340.     if (!confirm_overwrite()) {
  2341.         fclose(fp);
  2342.         return;
  2343.     }
  2344.     }
  2345.     fclose(fp);
  2346.     sprintf(buf2, "compress > %s", saved_cmap_file);
  2347.     fp = popen(buf2, "w");
  2348.     fwrite(color, sizeof(*color), CMAPLEN, fp);
  2349.     err = fclose(fp);
  2350.     if (err) {
  2351.     sprintf(buf1, "pclose returned %d", err);
  2352.     show_msg(buf1);
  2353.     return;
  2354.     }
  2355.     strcat(buf1, " saved");
  2356.     show_msg(buf1);
  2357. }
  2358.  
  2359.  
  2360. cmap_load()
  2361. {                    /* load colormap */
  2362.     FILE   *fp;
  2363.     int     k, file_len;
  2364.  
  2365.     clear_msg();
  2366.     if (invalid_set_pressed())
  2367.     return;
  2368.     if (setting_sequence)
  2369.     add_sequence(cmap_load);
  2370.     get_msg("Load color file:", buf1, BUFLEN, saved_cmap_file);
  2371.     if (buf1[0] == NULL)
  2372.     return;
  2373.     if (expand_fname(buf1, buf1))
  2374.     return;
  2375.     strcpy(saved_cmap_file,buf1);
  2376.     if (!strcmp(&buf1[strlen(buf1)-2], ".Z")) {
  2377.     cmap_load_compressed(buf1);
  2378.     return;
  2379.     }
  2380.     if (!(fp = fopen(buf1, "r"))) {
  2381.     sprintf(buf2,"%s/%s",Cmap_dir,buf1);
  2382.     if (!(fp = fopen(buf2, "r"))) {
  2383.         cmap_load_compressed(buf1);
  2384.         return;
  2385.     }
  2386.     }
  2387.     for (k=0; k < 256; k++)
  2388.     color2[k] = color[k];    /* copy old colormap into new one first */
  2389.     k = 0;
  2390.     while (fread(&color2[k], sizeof(int), 1, fp) == 1) {
  2391.     k++;
  2392.     if (k > 256) {
  2393.         fclose(fp);
  2394.         return;
  2395.     }
  2396.     }
  2397.     if ((k != 16) && (k != 256)) {
  2398.     clear_msg();
  2399.     sprintf(buf1,"Bad colormap length: %d",file_len);
  2400.     show_msg(buf1);
  2401.     return;
  2402.     }
  2403.     fclose(fp);
  2404.     if (color2[0] == color2[255]) {
  2405.     clear_msg();
  2406.     show_msg("Invalid colormap");
  2407.     show_msg("Entry 0 same as entry 255");
  2408.     return;
  2409.     }
  2410.  
  2411.     if (blackwhite) {
  2412.     for (k=0; k < 256; k++) {
  2413.         if (color2[k] > CMAPLEN) {
  2414.         show_msg("Error in colormap data");
  2415.         return;
  2416.         }
  2417.         else
  2418.         color[k] = color2[k];
  2419.     }
  2420.     display_image();
  2421.     }
  2422.     else {
  2423.     for (k = 0; k < 256; k++)
  2424.         set_cmap_entry(k, color2[k]);
  2425.     pw_setcmsname(pw, cmap_name);
  2426.     pw_putcolormap(pw, 0, 256, red, green, blue);
  2427.     pw_setcmsname(window_pw, cmap_name2);
  2428.     pw_putcolormap(window_pw, 0, 256, red, green, blue);
  2429.     pw_setcmsname(panel_pw, cmap_name3);
  2430.     pw_putcolormap(panel_pw, 0, 256, red, green, blue);
  2431.     }
  2432. }
  2433.  
  2434.  
  2435. cmap_load_compressed(fname)
  2436. char *fname;
  2437. {                    /* load colormap */
  2438.     FILE   *fp;
  2439.     int     k, file_len;
  2440.     struct stat statbuf;
  2441.     int err;
  2442.  
  2443.     if (!strcmp(&fname[strlen(fname)-2],".Z"))
  2444.     strcpy(buf1, fname);
  2445.     else
  2446.     sprintf(buf1, "%s.Z", fname);
  2447.     if (!stat(buf1, &statbuf)) {
  2448.     sprintf(buf2, "uncompress -c %s", buf1);
  2449.     if (!(fp = popen(buf2, "r"))) {
  2450.         show_msg("Error trying to open pipe");
  2451.         return;
  2452.     }
  2453.     }
  2454.     else {
  2455.     sprintf(buf2, "%s/%s", Cmap_dir, buf1);
  2456.     if (!stat(buf2, &statbuf)) {
  2457.         sprintf(buf2, "uncompress -c %s/%s",Cmap_dir, buf1);
  2458.         if (!(fp = popen(buf2, "r"))) {
  2459.         show_msg("Error trying to open pipe");
  2460.         return;
  2461.         }
  2462.     }
  2463.     else {
  2464.         show_msg("No such cmap");
  2465.         return;
  2466.     }
  2467.     }
  2468.     strcpy(saved_cmap_file,buf1);
  2469.     for (k=0; k < 256; k++)
  2470.     color2[k] = color[k];    /* copy old colormap into new one first */
  2471.     k = 0;
  2472.     while (fread(&color2[k], sizeof(int), 1, fp) == 1) {
  2473.     k++;
  2474.     if (k > 256) {
  2475.         pclose(fp);
  2476.         return;
  2477.     }
  2478.     }
  2479.     if ((k != 16) && (k != 256)) {
  2480.     clear_msg();
  2481.     sprintf(buf1,"Bad colormap length: %d",file_len);
  2482.     show_msg(buf1);
  2483.     return;
  2484.     }
  2485.     err = pclose(fp);
  2486.     if (err) {
  2487.     sprintf(buf2, "pclose returned %d", err);
  2488.     show_msg(err);
  2489.     return;
  2490.     }
  2491.     if (color2[0] == color2[255]) {
  2492.     clear_msg();
  2493.     show_msg("Invalid colormap");
  2494.     show_msg("Entry 0 same as entry 255");
  2495.     return;
  2496.     }
  2497.  
  2498.     if (blackwhite) {
  2499.     for (k=0; k < 256; k++) {
  2500.         if (color2[k] > CMAPLEN) {
  2501.         show_msg("Error in colormap data");
  2502.         return;
  2503.         }
  2504.         else
  2505.         color[k] = color2[k];
  2506.     }
  2507.     display_image();
  2508.     }
  2509.     else {
  2510.     for (k = 0; k < 256; k++)
  2511.         set_cmap_entry(k, color2[k]);
  2512.     pw_setcmsname(pw, cmap_name);
  2513.     pw_putcolormap(pw, 0, 256, red, green, blue);
  2514.     pw_setcmsname(window_pw, cmap_name2);
  2515.     pw_putcolormap(window_pw, 0, 256, red, green, blue);
  2516.     pw_setcmsname(panel_pw, cmap_name3);
  2517.     pw_putcolormap(panel_pw, 0, 256, red, green, blue);
  2518.     }
  2519. }
  2520.  
  2521.  
  2522. /*
  2523.  * Magnify given portion of image by factor of m
  2524.  */
  2525. magnify_image(m, side, xstart, ystart)
  2526. int m, side, xstart, ystart;
  2527. {
  2528.     register int x, y, delx, dely;
  2529.     register unsigned char value;
  2530.     register unsigned char *srow, *trow, *sptr, *tptr, *tptr2, *tgroup;
  2531.     unsigned int size;
  2532.  
  2533.     size = side * m / 32;
  2534.     srow = ca + ABASE + ystart * B + xstart;
  2535.     if (blackwhite) {
  2536.     pr_rop(tmpmag,0,0,side*m,side*m,PIX_SRC,NULL,0,0);
  2537.     for (y=0; y<m*side; y+=m) {
  2538.         sptr = srow;
  2539.         for (x=0; x<m*side; x+=m) {
  2540.         value = *(sptr++);
  2541.         if (color[value])
  2542.             pr_rop(tmpmag,x,y,m,m,PIX_SRC,&textures_pr[color[value]],0,0);
  2543.         }
  2544.         srow += B;
  2545.     }
  2546.     pw_rop(pw,0,0,side*m,side*m,PIX_SRC,tmpmag,0,0);
  2547.     }
  2548.     else {
  2549.     /*
  2550.     trow = (unsigned char *) (mpr_d(tmpmag)->md_image);
  2551.     for (y = 0; y < side; y++) {
  2552.         tptr = trow;
  2553.         sptr = srow;
  2554.         for (x = 0; x < side; x++) {
  2555.         value = *(sptr++);
  2556.         for (delx = 0; delx < m; delx++) {
  2557.             *(tptr++) = value;
  2558.         }
  2559.         }
  2560.         tgroup = trow;
  2561.         trow += MAXSIZE;
  2562.         x = size;
  2563.         for (dely = 1; dely < m; dely++) {
  2564.         tptr = trow;
  2565.         sptr = tgroup;
  2566.         for (delx = 0; delx < x; delx++) {
  2567.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2568.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2569.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2570.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2571.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2572.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2573.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2574.             *(((long *) tptr)++) = *(((long *) sptr)++);
  2575.         }
  2576.         trow += MAXSIZE;
  2577.         }
  2578.         srow += B;
  2579.     }
  2580.     pw_rop(pw, 0, 0, side * m, side * m, PIX_SRC, tmpmag, 0, 0);
  2581.     */
  2582.     trow = (unsigned char *) (mpr_d(tmpmag)->md_image);
  2583.     for (y = 0; y < side; y++) {
  2584.         tptr2 = trow;
  2585.         sptr = srow;
  2586.         for (x = 0; x < side; x++) {
  2587.         value = *(sptr++);
  2588.         for (dely = 0; dely < m; dely++) {
  2589.             tptr = tptr2 + dely*MAXSIZE;
  2590.             for (delx = 0; delx < m; delx++) {
  2591.             *(tptr++) = value;
  2592.             }
  2593.         }
  2594.         tptr2 += m;
  2595.         }
  2596.         trow += MAXSIZE*m;
  2597.         srow += B;
  2598.     }
  2599.     pw_rop(pw, 0, 0, side * m, side * m, PIX_SRC, tmpmag, 0, 0);
  2600.     
  2601.     }
  2602.     /* draw tmpmag on canvas */
  2603. }
  2604.  
  2605.  
  2606. /*
  2607.  * The following "toggle" routines are here in the SunView-specific file
  2608.  * because they have to alter the strings in the control-panel menus.
  2609.  */
  2610. toggle_save_in_image_dir_proc()
  2611. {
  2612.     Menu_item item;
  2613.     
  2614.     clear_msg();
  2615.     if (invalid_set_pressed())
  2616.     return;
  2617.     if (setting_sequence)
  2618.     add_sequence(toggle_save_in_image_dir_proc);
  2619.     save_in_image_dir = 1 - save_in_image_dir;
  2620.     item = menu_get(defaults_image_menu, MENU_NTH_ITEM, 1);
  2621.     if (save_in_image_dir) {    /* is enabled now */
  2622.     menu_set(item, MENU_STRING, "Save in current working dir", 0);
  2623.     show_msg("Images will be saved");
  2624.     show_msg("in Image-dir");
  2625.     }
  2626.     else {
  2627.     menu_set(item, MENU_STRING, "Save in Image-dir", 0);
  2628.     show_msg("Images will be saved in");
  2629.     show_msg("current working dir");
  2630.     }
  2631. }
  2632.  
  2633.  
  2634. toggle_save_images_compressed()
  2635. {
  2636.     Menu_item item;
  2637.     
  2638.     clear_msg();
  2639.     if (invalid_set_pressed())
  2640.     return;
  2641.     if (setting_sequence)
  2642.     add_sequence(toggle_save_images_compressed);
  2643.     save_images_compressed = 1 - save_images_compressed;
  2644.     item = menu_get(defaults_image_menu, MENU_NTH_ITEM, 2);
  2645.     if (save_images_compressed) {
  2646.     menu_set(item, MENU_STRING, "Save uncompressed", 0);
  2647.     show_msg("Images will be saved");
  2648.     show_msg("in compressed form");
  2649.     }
  2650.     else {
  2651.     menu_set(item, MENU_STRING, "Save compressed", 0);
  2652.     show_msg("Images will be saved in");
  2653.     show_msg("uncompressed form");
  2654.     }
  2655. }
  2656.  
  2657.  
  2658. toggle_save_in_LT_dir_proc()
  2659. {
  2660.     Menu_item item;
  2661.     
  2662.     clear_msg();
  2663.     if (invalid_set_pressed())
  2664.     return;
  2665.     if (setting_sequence)
  2666.     add_sequence(toggle_save_in_LT_dir_proc);
  2667.     save_in_LT_dir = 1 - save_in_LT_dir;
  2668.     item = menu_get(defaults_rule_menu, MENU_NTH_ITEM, 1);
  2669.     if (save_in_LT_dir) {    /* is enabled now */
  2670.     menu_set(item, MENU_STRING, "Save in current working dir", 0);
  2671.     show_msg("LT's will be saved");
  2672.     show_msg("in Table-dir");
  2673.     }
  2674.     else {
  2675.     menu_set(item, MENU_STRING, "Save in Table-dir", 0);
  2676.     show_msg("LT's will be saved in");
  2677.     show_msg("current working dir");
  2678.     }
  2679. }
  2680.  
  2681.  
  2682. toggle_save_LT_compressed()
  2683. {
  2684.     Menu_item item;
  2685.     
  2686.     clear_msg();
  2687.     if (invalid_set_pressed())
  2688.     return;
  2689.     if (setting_sequence)
  2690.     add_sequence(toggle_save_LT_compressed);
  2691.     save_LT_compressed = 1 - save_LT_compressed;
  2692.     item = menu_get(defaults_rule_menu, MENU_NTH_ITEM, 2);
  2693.     if (save_LT_compressed) {
  2694.     menu_set(item, MENU_STRING, "Save uncompressed", 0);
  2695.     show_msg("LT's will be saved");
  2696.     show_msg("in compressed form");
  2697.     }
  2698.     else {
  2699.     menu_set(item, MENU_STRING, "Save compressed", 0);
  2700.     show_msg("LT's will be saved");
  2701.     show_msg("in uncompressed form");
  2702.     }
  2703. }
  2704.  
  2705.  
  2706. toggle_save_in_cmap_dir_proc()
  2707. {
  2708.     Menu_item item;
  2709.     
  2710.     clear_msg();
  2711.     if (invalid_set_pressed())
  2712.     return;
  2713.     if (setting_sequence)
  2714.     add_sequence(toggle_save_in_cmap_dir_proc);
  2715.     save_in_cmap_dir = 1 - save_in_cmap_dir;
  2716.     item = menu_get(defaults_cmap_menu, MENU_NTH_ITEM, 1);
  2717.     if (save_in_cmap_dir) {    /* is enabled now */
  2718.     menu_set(item, MENU_STRING, "Save in current working dir", 0);
  2719.     show_msg("Cmaps will be saved");
  2720.     show_msg("in Cmap-dir");
  2721.     }
  2722.     else {
  2723.     menu_set(item, MENU_STRING, "Save in Cmap-dir", 0);
  2724.     show_msg("Cmaps will be saved in");
  2725.     show_msg("current working dir");
  2726.     }
  2727. }
  2728.     
  2729.  
  2730. toggle_auto_image_change_proc()
  2731. {
  2732.     Menu_item item;
  2733.  
  2734.     clear_msg();
  2735.     if (invalid_set_pressed())
  2736.     return;
  2737.     if (setting_sequence)
  2738.     add_sequence(toggle_auto_image_change_proc);
  2739.     auto_image_change = 1 - auto_image_change;
  2740.     item = menu_get(defaults_image_menu, MENU_NTH_ITEM, 4);
  2741.     if (auto_image_change) {    /* it is enabled now */
  2742.     menu_set(item, MENU_STRING, "Disable auto-change", 0);
  2743.     show_msg("Auto image-change enabled");
  2744.     }
  2745.     else {
  2746.     menu_set(item, MENU_STRING, "Enable auto-change", 0);
  2747.     show_msg("Auto image-change disabled");
  2748.     }
  2749. }
  2750.  
  2751.  
  2752. toggle_auto_nhood_change_proc()
  2753. {
  2754.     Menu_item item;
  2755.  
  2756.     clear_msg();
  2757.     if (invalid_set_pressed())
  2758.     return;
  2759.     if (setting_sequence)
  2760.     add_sequence(toggle_auto_nhood_change_proc);
  2761.     auto_nhood_change = 1 - auto_nhood_change;
  2762.     item = menu_get(defaults_rule_menu, MENU_NTH_ITEM, 5);
  2763.     if (auto_nhood_change) {
  2764.     menu_set(item, MENU_STRING, "Disable auto-change", 0);
  2765.     show_msg("Auto nhood-change enabled");
  2766.     }
  2767.     else {
  2768.     menu_set(item, MENU_STRING, "Enable auto-change", 0);
  2769.     show_msg("Auto nhood-change disabled");
  2770.     }
  2771. }
  2772.  
  2773.  
  2774. tsymmetry()
  2775. {                    /* toggle table symmetry */
  2776.     Menu_item item;
  2777.     
  2778.     clear_msg();
  2779.     if (invalid_set_pressed())
  2780.     return;
  2781.     if (setting_sequence)
  2782.     add_sequence(tsymmetry);
  2783.     table_symmetry = 1-table_symmetry;
  2784.     item = menu_get(rules_menu, MENU_NTH_ITEM, 5);
  2785.     if (table_symmetry) {
  2786.     show_msg("Symmetry enabled");
  2787.     menu_set(item, MENU_STRING, "Disable symmetry", 0);
  2788.     }
  2789.     else {
  2790.     show_msg("Symmetry disabled");
  2791.     menu_set(item, MENU_STRING, "Enable symmetry", 0);
  2792.     }
  2793. }
  2794.  
  2795.  
  2796. FB_toggle()
  2797. {
  2798.     Menu_item item;
  2799.  
  2800.     clear_msg();
  2801.     if (invalid_set_pressed())
  2802.     return;
  2803.     if (setting_sequence)
  2804.     add_sequence(FB_toggle);
  2805.     use_FB = 1 - use_FB;
  2806.     item = menu_get(defaults_CM_menu, MENU_NTH_ITEM, 4);
  2807.     if (use_FB)
  2808.     menu_set(item, MENU_STRING, "Disable FB display", 0);
  2809.     else
  2810.     menu_set(item, MENU_STRING, "Enable FB display", 0);
  2811.     CM_set_displays();
  2812. }
  2813.  
  2814.  
  2815.  
  2816. Sun_disp_toggle()
  2817. {
  2818.     Menu_item item;
  2819.  
  2820.     clear_msg();
  2821.     if (invalid_set_pressed())
  2822.     return;
  2823.     if (setting_sequence)
  2824.     add_sequence(Sun_disp_toggle);
  2825.     use_Sun_disp = 1 - use_Sun_disp;
  2826.     item = menu_get(defaults_CM_menu, MENU_NTH_ITEM, 5);
  2827.     if (use_Sun_disp)
  2828.     menu_set(item, MENU_STRING, "Disable Sun display", 0);
  2829.     else
  2830.     menu_set(item, MENU_STRING, "Enable Sun display", 0);
  2831.     CM_set_displays();
  2832. }
  2833.  
  2834.  
  2835. /***** CM-related stuff *****/
  2836.  
  2837. static void
  2838. CM_send_zoom_proc(item, value, event)
  2839. Panel_item item;
  2840. int value;
  2841. Event *event;
  2842. {
  2843.     CM_zoom = value;
  2844.     if (use_CM)
  2845.     CM_send_zoom();
  2846. }
  2847.  
  2848.  
  2849. static void
  2850. CM_send_panx_proc(item, value, event)
  2851. Panel_item item;
  2852. int value;
  2853. Event *event;
  2854. {
  2855.     CM_panx = value;
  2856.     if (use_CM)
  2857.     CM_send_pan();
  2858. }
  2859.  
  2860.  
  2861. static void
  2862. CM_send_pany_proc(item, value, event)
  2863. Panel_item item;
  2864. int value;
  2865. Event *event;
  2866. {
  2867.     CM_pany = value;
  2868.     if (use_CM)
  2869.     CM_send_pan();
  2870. }   
  2871.  
  2872.  
  2873. void
  2874. CM_get_dirs()
  2875. {
  2876.     CM_get_fcn_dir();
  2877.     CM_get_LT_dir();
  2878.     CM_get_image_dir();
  2879.     panel_set_value(def_CM_imagedir_item, CM_image_dir);
  2880.     panel_set_value(def_CM_fcndir_item, CM_fcn_dir);
  2881.     panel_set_value(def_CM_LTdir_item, CM_LT_dir);
  2882. }
  2883.  
  2884.  
  2885.