v01i083: Trackertool-Graph data coming from a pipe (Sunview), Part02/02
Charles Mcgrew
mcgrew at dartagnan.rutgers.edu
Wed Nov 29 04:25:47 AEST 1989
Submitted-by: rphroy!rrichter at edsews.eds.com (Roy Richter)
Posting-number: Volume 1, Issue 83
Archive-name: trackertool/part02
#--------------------------------CUT HERE-------------------------------------
#! /bin/sh
#
# This is a shell archive. Save this into a file, edit it
# and delete all lines above this comment. Then give this
# file to sh by executing the command "sh file". The files
# will be extracted into the current directory owned by
# you with default permissions.
#
# The files contained herein are:
#
# -rw-r--r-- 1 roy 1623 Oct 13 16:29 make_base.c
# -rw-r--r-- 1 roy 2230 Oct 12 10:00 make_labels.c
# -rw-r--r-- 1 roy 3544 Oct 12 10:01 make_panel.c
# -rw-r--r-- 1 roy 3562 Sep 14 16:28 make_props.c
# -rw-r--r-- 1 roy 4800 Nov 29 09:58 make_sub.c
# -rw-r--r-- 1 roy 3607 Oct 12 11:42 pipe_reader.c
# -rw-r--r-- 1 roy 1283 Oct 12 10:58 quit_proc.c
# -rw-r--r-- 1 roy 8657 Oct 12 10:32 repaint_canvas.c
# -rw-r--r-- 1 roy 1846 Sep 14 16:28 reset_axis_proc.c
# -rw-r--r-- 1 roy 1535 Nov 9 11:45 rewrite_text.c
# -rw-r--r-- 1 roy 2859 Nov 29 10:04 trackertool.c
# -rw-r--r-- 1 roy 2057 Sep 14 16:28 update_arrays.c
# -rw-r--r-- 1 roy 2275 Sep 14 16:28 update_canvas.c
# -rw-r--r-- 1 roy 1658 Sep 14 16:28 update_displays.c
# -rw-r--r-- 1 roy 657 Nov 9 11:37 update_textsw.c
# -rw-r--r-- 1 roy 6211 Nov 29 10:06 zoom_event.c
#
echo 'x - make_base.c'
if test -f make_base.c
then echo 'shar: not overwriting make_base.c'; else
sed 's/^X//' << '________This_Is_The_END________' > make_base.c
X#include "trackertool.h"
X
Xstatic short icon_image[] = {
X#include "trackertool.icon"
X};
XDEFINE_ICON_FROM_IMAGE(trackertool_icon, icon_image);
X
XFrame
Xmake_base(argc, argv)
X int argc;
X char **argv;
X{
X Frame base_frame;
X
X void make_sub();
X void quit_proc();
X Notify_value close_them_proc();
X
X base_frame = window_create(NULL, FRAME,
X FRAME_LABEL, "Trackertool Copyright 1988, GM Corp.",
X FRAME_ICON, &trackertool_icon,
X WIN_ERROR_MSG, "Can't create window",
X FRAME_ARGS, argc, argv,
X 0);
X
X main_panel = window_create(base_frame, PANEL, 0);
X
X view_button = panel_create_item(main_panel, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(main_panel, "Create View", 0, 0),
X PANEL_NOTIFY_PROC, make_sub,
X 0);
X
X hide_button = panel_create_item(main_panel, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(main_panel, "Hide", 0, 0),
X PANEL_NOTIFY_PROC, quit_proc,
X 0);
X
X quit_button = panel_create_item(main_panel, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(main_panel, "Quit", 0, 0),
X PANEL_NOTIFY_PROC, quit_proc,
X 0);
X
X num_message = panel_create_item(main_panel, PANEL_MESSAGE,
X PANEL_LABEL_STRING, "Reading..... Values: 0",
X 0);
X
X window_fit(main_panel);
X window_fit(base_frame);
X
X num_of_subframes = -1; /* subframe[0] not yet created */
X
X /*
X * File descriptor usage: 1 frame 1 panel
X */
X num_fd = num_fd + 2;
X
X /* make sure I get when the base_frame opens/closes */
X notify_interpose_event_func(base_frame, close_them_proc,
X NOTIFY_SAFE);
X
X return base_frame;
X}
________This_Is_The_END________
if test `wc -l < make_base.c` -ne 62; then
echo -n 'shar: make_base.c was damaged during transit'
echo ' (should have been 62 bytes)'
fi
fi ; : end of overwriting check
echo 'x - make_labels.c'
if test -f make_labels.c
then echo 'shar: not overwriting make_labels.c'; else
sed 's/^X//' << '________This_Is_The_END________' > make_labels.c
X#include <stdio.h>
X#include <string.h>
X#include "trackertool.h"
X
Xvoid
Xmake_labels()
X{
X /*
X * make_labels will read in the first line of stdin and setup the
X * variable arrays to accept subsequent data. The first array is
X * dummy, the record number. Both left and right-justified arrays
X * are kept.
X */
X
X char s_r[MAX_STR_LEN], s_l[MAX_STR_LEN];
X int get_next_string();
X
X num_arrays = -1;
X num_values = -1;
X
X while (get_next_string(s_l, s_r, MAX_STR_LEN, stdin) != 0) {
X if (num_arrays == MAX_ARRAYS - 2) {
X fprintf(stderr, "Maximum number of arrays reached.\n");
X return;
X }
X array_ptr[++num_arrays] = ALLOC(Array);
X if (!array_ptr[num_arrays]) {
X fprintf(stderr, "Out of memory allocating array %d.\n", num_arrays);
X num_arrays -= 2;
X break;
X }
X array_ptr[num_arrays]->values =
X (float *) malloc((unsigned) (MAX_VALUES * sizeof(float)));
X array_ptr[num_arrays]->log_values =
X (float *) malloc((unsigned) (MAX_VALUES * sizeof(float)));
X if (!array_ptr[num_arrays]->values ||
X !array_ptr[num_arrays]->log_values) {
X fprintf(stderr, "Out of memory allocating array %d.\n", num_arrays);
X num_arrays -= 2;
X break;
X }
X strcpy(array_ptr[num_arrays]->label_l, s_l);
X strcpy(array_ptr[num_arrays]->label_r, s_r);
X if (echo_on)
X printf("%s ", s_l);
X }
X if (echo_on)
X printf("\n", s_l);
X
X if (num_arrays < 0) {
X fprintf(stderr, "Trackertool: no arrays input. Stopping.\n");
X exit(3);
X }
X /* allocate record # array if not already done */
X if (!array_ptr[++num_arrays]) {
X array_ptr[num_arrays] = ALLOC(Array);
X array_ptr[num_arrays]->values =
X (float *) malloc((unsigned) (MAX_VALUES * sizeof(float)));
X array_ptr[num_arrays]->log_values =
X (float *) malloc((unsigned) (MAX_VALUES * sizeof(float)));
X if (!array_ptr[num_arrays]->values ||
X !array_ptr[num_arrays]->log_values) {
X fprintf(stderr, "Out of memory allocating for Record Number.\n");
X fprintf(stderr, "%d arrays read in", --num_arrays);
X fprintf(stderr, " with %d values in each array.\n", MAX_VALUES);
X }
X }
X strcpy(array_ptr[num_arrays]->label_l, "Record_# ");
X strcpy(array_ptr[num_arrays]->label_r, " Record_#");
X
X return;
X}
________This_Is_The_END________
if test `wc -l < make_labels.c` -ne 72; then
echo -n 'shar: make_labels.c was damaged during transit'
echo ' (should have been 72 bytes)'
fi
fi ; : end of overwriting check
echo 'x - make_panel.c'
if test -f make_panel.c
then echo 'shar: not overwriting make_panel.c'; else
sed 's/^X//' << '________This_Is_The_END________' > make_panel.c
X#include <stdio.h>
X#include "trackertool.h"
X#define TEXT 0 /* the toggle values as set in make_sub */
X#define GRAPH 1
X#define PROPS 2
X#define PAN_L 3
X#define toggle_bit_on(value,bit) ((value) & (1 << (bit)))
X#define set_bit_on(value,bit) ((value) |= (1 << (bit)))
X
Xvoid
Xmake_panel(menu, menu_item)
X Menu menu;
X Menu_item menu_item;
X /*
X * Re-shows the main panel after it's been deleted.
X */
X{
X Subframe *subframe_ptr;
X Panel panel;
X Attr_avlist choice_list[MAX_ARRAYS + 2];
X Rect *rect;
X unsigned int value;
X Event *event;
X int i;
X
X void init_choices();
X void display_mode_proc();
X void change_variables_proc();
X void kill_view_proc();
X
X /* See if we have a free fd to create panel. */
X if (++num_fd > MAX_FD) {
X fprintf(stderr, "Too many windows open. Request ignored.\n");
X num_fd--;
X return;
X }
X /* Find which subframe we are in */
X subframe_ptr = NULL;
X for (i = 0; i <= num_of_subframes; i++) {
X if (menu_item == subframe[i]->menu_item)
X subframe_ptr = subframe[i];
X }
X if (subframe_ptr == NULL) {
X printf(stderr, "Internal error: can't find subframe.\n");
X return;
X }
X /* Turn on the frame namestripe and turn off the menu item */
X window_set(subframe_ptr->handle, FRAME_SHOW_LABEL, TRUE, 0);
X menu_set(subframe_ptr->menu_item, MENU_INACTIVE, TRUE, 0);
X
X /* Keep the current state of the world in value, for later use */
X value = 0;
X if (subframe_ptr->textsw)
X set_bit_on(value, TEXT);
X if (subframe_ptr->canvas)
X set_bit_on(value, GRAPH);
X if (subframe_ptr->props)
X set_bit_on(value, PROPS);
X set_bit_on(value, PAN_L); /* since we want it on */
X
X /*
X * Make the panel again, from scratch; only use the data
X * preferences already stored to set initial values for items
X */
X panel = window_create(subframe_ptr->handle, PANEL,
X WIN_CLIENT_DATA, subframe_ptr,
X WIN_X, 0,
X WIN_Y, 0,
X WIN_WIDTH, (int) window_get(subframe_ptr->handle, WIN_WIDTH, 0),
X 0);
X subframe_ptr->panel = panel;
X
X subframe_ptr->choice = panel_create_item(panel, PANEL_TOGGLE,
X PANEL_LABEL_STRING, "Display mode:",
X PANEL_CHOICE_STRINGS, "Text", "Graph", "Props", "This Panel", 0,
X PANEL_TOGGLE_VALUE, TEXT, toggle_bit_on(value, TEXT),
X PANEL_TOGGLE_VALUE, GRAPH, toggle_bit_on(value, GRAPH),
X PANEL_TOGGLE_VALUE, PROPS, toggle_bit_on(value, PROPS),
X PANEL_TOGGLE_VALUE, PAN_L, toggle_bit_on(value, PAN_L),
X PANEL_NOTIFY_PROC, display_mode_proc,
X 0);
X rect = (Rect *) panel_get(subframe_ptr->choice, PANEL_ITEM_RECT, 0);
X init_choices(choice_list);
X panel_create_item(panel, PANEL_CYCLE,
X PANEL_LABEL_STRING, "Abcissa:",
X ATTR_LIST, choice_list,
X PANEL_NOTIFY_PROC, change_variables_proc,
X PANEL_ITEM_X, 10,
X PANEL_ITEM_Y, rect->r_height + 10,
X PANEL_CLIENT_DATA, 'x',
X PANEL_VALUE, 0,
X 0);
X panel_create_item(panel, PANEL_CYCLE,
X PANEL_LABEL_STRING, "Ordinate:",
X ATTR_LIST, choice_list,
X PANEL_NOTIFY_PROC, change_variables_proc,
X PANEL_CLIENT_DATA, 'y',
X PANEL_VALUE,
X (num_of_subframes + 1 < num_arrays) ? num_of_subframes + 1 : 1,
X 0);
X panel_create_item(panel, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(panel, "Kill View", 0, 0),
X PANEL_NOTIFY_PROC, kill_view_proc,
X 0);
X window_fit_height(panel);
X
X /*
X * now we have our control panel back again. call display_mode_proc
X * to make the other panels.
X */
X display_mode_proc(subframe_ptr->choice, value, event);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < make_panel.c` -ne 114; then
echo -n 'shar: make_panel.c was damaged during transit'
echo ' (should have been 114 bytes)'
fi
fi ; : end of overwriting check
echo 'x - make_props.c'
if test -f make_props.c
then echo 'shar: not overwriting make_props.c'; else
sed 's/^X//' << '________This_Is_The_END________' > make_props.c
X#include <string.h>
X#include "trackertool.h"
X
XPanel
Xmake_props(subframe_ptr, frame, above_panel)
X Subframe *subframe_ptr;
X Frame frame;
X Panel above_panel;
X/*
X * Creates the props panel
X */
X{
X Panel props;
X
X Panel_item item;
X Rect *item_rect;
X
X void change_axis_proc();
X void reset_axis_proc();
X void change_connect_proc();
X
X char text_value[18];
X char *gcvt();
X
X if (above_panel != NULL)
X props = window_create(frame, PANEL,
X WIN_BELOW, above_panel,
X WIN_X, 0,
X WIN_CLIENT_DATA, subframe_ptr,
X 0);
X else
X props = window_create(frame, PANEL,
X WIN_X, 0,
X WIN_Y, 0,
X WIN_CLIENT_DATA, subframe_ptr,
X 0);
X panel_create_item(props, PANEL_CYCLE,
X PANEL_LABEL_STRING, "Draw Mode:",
X PANEL_CHOICE_STRINGS, "Points", "Lines", 0,
X PANEL_VALUE, subframe_ptr->connect_points,
X PANEL_NOTIFY_PROC, change_connect_proc,
X 0);
X
X window_fit_width(props);
X
X item = panel_create_item(props, PANEL_TOGGLE,
X PANEL_LAYOUT, PANEL_VERTICAL,
X PANEL_LABEL_STRING, "X",
X PANEL_CHOICE_STRINGS, "Auto min", "Auto Max",
X "Grid", "Log", 0,
X PANEL_TOGGLE_VALUE, 0, subframe_ptr->x_min_auto,
X PANEL_TOGGLE_VALUE, 1, subframe_ptr->x_max_auto,
X PANEL_TOGGLE_VALUE, 2, subframe_ptr->x_grid,
X PANEL_TOGGLE_VALUE, 3, subframe_ptr->x_log,
X PANEL_NOTIFY_PROC, change_axis_proc,
X PANEL_SHOW_MENU, FALSE,
X PANEL_CLIENT_DATA, 'x',
X 0);
X item_rect = (Rect *) panel_get(item, PANEL_ITEM_RECT, 0);
X panel_create_item(props, PANEL_TOGGLE,
X PANEL_LAYOUT, PANEL_VERTICAL,
X PANEL_LABEL_STRING, "Y",
X PANEL_CHOICE_STRINGS, " ", " ", " ", " ", 0,
X PANEL_TOGGLE_VALUE, 0, subframe_ptr->y_min_auto,
X PANEL_TOGGLE_VALUE, 1, subframe_ptr->y_max_auto,
X PANEL_TOGGLE_VALUE, 2, subframe_ptr->y_grid,
X PANEL_TOGGLE_VALUE, 3, subframe_ptr->y_log,
X PANEL_NOTIFY_PROC, change_axis_proc,
X PANEL_SHOW_MENU, FALSE,
X PANEL_CLIENT_DATA, 'y',
X PANEL_ITEM_X, item_rect->r_left + item_rect->r_width + 10,
X 0);
X
X panel_create_item(props, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(props, "Reset", 0, 0),
X PANEL_NOTIFY_PROC, reset_axis_proc,
X PANEL_CLIENT_DATA, 1,
X 0);
X panel_create_item(props, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(props, "Redraw", 0, 0),
X PANEL_NOTIFY_PROC, reset_axis_proc,
X PANEL_CLIENT_DATA, 0,
X 0);
X
X if (subframe_ptr->x_min_auto)
X strcpy(text_value, "Not set");
X else
X gcvt(subframe_ptr->x_min, 8, text_value);
X subframe_ptr->props_x_min = panel_create_item(props, PANEL_TEXT,
X PANEL_LABEL_STRING, "X min:",
X PANEL_VALUE_DISPLAY_LENGTH, MAX_STR_LEN,
X PANEL_VALUE, text_value,
X 0);
X
X if (subframe_ptr->x_max_auto)
X strcpy(text_value, "Not set");
X else
X gcvt(subframe_ptr->x_max, 8, text_value);
X subframe_ptr->props_x_max = panel_create_item(props, PANEL_TEXT,
X PANEL_LABEL_STRING, "X max:",
X PANEL_VALUE_DISPLAY_LENGTH, MAX_STR_LEN,
X PANEL_VALUE, text_value,
X 0);
X
X if (subframe_ptr->y_min_auto)
X strcpy(text_value, "Not set");
X else
X gcvt(subframe_ptr->y_min, 8, text_value);
X subframe_ptr->props_y_min = panel_create_item(props, PANEL_TEXT,
X PANEL_LABEL_STRING, "Y min:",
X PANEL_VALUE_DISPLAY_LENGTH, MAX_STR_LEN,
X PANEL_VALUE, text_value,
X 0);
X
X if (subframe_ptr->y_max_auto)
X strcpy(text_value, "Not set");
X else
X gcvt(subframe_ptr->y_max, 8, text_value);
X subframe_ptr->props_y_max = panel_create_item(props, PANEL_TEXT,
X PANEL_LABEL_STRING, "Y max:",
X PANEL_VALUE_DISPLAY_LENGTH, MAX_STR_LEN,
X PANEL_VALUE, text_value,
X 0);
X
X return (props);
X}
________This_Is_The_END________
if test `wc -l < make_props.c` -ne 126; then
echo -n 'shar: make_props.c was damaged during transit'
echo ' (should have been 126 bytes)'
fi
fi ; : end of overwriting check
echo 'x - make_sub.c'
if test -f make_sub.c
then echo 'shar: not overwriting make_sub.c'; else
sed 's/^X//' << '________This_Is_The_END________' > make_sub.c
X#include <stdio.h>
X#include "trackertool.h"
X
Xvoid
Xmake_sub(button)
X Panel_item button;
X{
X Frame frame, base_frame;
X Panel panel;
X Subframe *subframe_ptr;
X Menu menu;
X Menu_item menu_item;
X
X void repaint_canvas();
X void display_mode_proc();
X void change_variables_proc();
X void kill_view_proc();
X void init_arrays();
X void init_choices();
X void make_panel();
X Notify_value zoom_event();
X
X char string[22];
X Attr_avlist choice_list[MAX_ARRAYS + 2];
X Rect *rect;
X
X /* gross hack from Chuck Musciano to remove subframe icon space */
X char *pos_hack[5];
X static char pos_hack_0[] = {""}, pos_hack_1[] = {"-WP"};
X char pos_hack_2[6] ,pos_hack_3[6];
X static char pos_hack_4[] = {""};
X Rect *fr;
X pos_hack[0]=pos_hack_0;
X pos_hack[1]=pos_hack_1;
X pos_hack[2]=pos_hack_2;
X pos_hack[3]=pos_hack_3;
X pos_hack[4]=pos_hack_4;
X
X /*
X * check file descriptors. We'll be making: 1 frame 1 panel 1
X * canvas
X */
X if (num_fd + 3 > MAX_FD) {
X fprintf(stderr, "Too many windows open. Create ignored.\n");
X panel_set(view_button, PANEL_SHOW_ITEM, FALSE, 0);
X return;
X } else
X num_fd = num_fd + 3;
X
X /* find the base frame of the button and its icon position */
X base_frame = (Frame) window_get(
X (Panel) panel_get(button, PANEL_PARENT_PANEL), WIN_OWNER);
X fr = (Rect *) window_get(base_frame, FRAME_CLOSED_RECT);
X sprintf(pos_hack[2], "%d", fr->r_left);
X sprintf(pos_hack[3], "%d", fr->r_top);
X
X /* create the new frame as a sub-frame of the base_frame. */
X sprintf(string, "Trackertool view #%2d", ++num_of_subframes + 1);
X frame = window_create(base_frame, FRAME,
X FRAME_ARGS, 4, pos_hack,
X FRAME_LABEL, string,
X WIN_CLIENT_DATA, num_of_subframes,
X FRAME_SHOW_LABEL, TRUE,
X WIN_ERROR_MSG, "Can't create subframe",
X 0);
X
X /* get memory for subframe register and register it */
X subframe[num_of_subframes] = ALLOC(Subframe);
X subframe_ptr = subframe[num_of_subframes];
X subframe_ptr->handle = frame;
X
X /* set the default variables */
X init_arrays(subframe_ptr);
X
X /* set the current label list */
X init_choices(choice_list);
X
X /* Create the various parts of the subframe */
X panel = window_create(frame, PANEL,
X WIN_CLIENT_DATA, subframe_ptr,
X 0);
X subframe_ptr->panel = panel;
X
X subframe_ptr->choice = panel_create_item(panel, PANEL_TOGGLE,
X PANEL_LABEL_STRING, "Display mode:",
X PANEL_CHOICE_STRINGS, "Text", "Graph", "Props", "This Panel", 0,
X PANEL_TOGGLE_VALUE, 1, TRUE,
X PANEL_TOGGLE_VALUE, 3, TRUE,
X PANEL_NOTIFY_PROC, display_mode_proc,
X 0);
X rect = (Rect *) panel_get(subframe_ptr->choice, PANEL_ITEM_RECT, 0);
X panel_create_item(panel, PANEL_CYCLE,
X PANEL_LABEL_STRING, "Abcissa:",
X ATTR_LIST, choice_list,
X PANEL_NOTIFY_PROC, change_variables_proc,
X PANEL_ITEM_X, 10,
X PANEL_ITEM_Y, rect->r_height + 10,
X PANEL_CLIENT_DATA, 'x',
X PANEL_VALUE, 0,
X 0);
X panel_create_item(panel, PANEL_CYCLE,
X PANEL_LABEL_STRING, "Ordinate:",
X ATTR_LIST, choice_list,
X PANEL_NOTIFY_PROC, change_variables_proc,
X PANEL_CLIENT_DATA, 'y',
X PANEL_VALUE,
X (num_of_subframes + 1 < num_arrays) ? num_of_subframes + 1 : 1,
X 0);
X panel_create_item(panel, PANEL_BUTTON,
X PANEL_LABEL_IMAGE, panel_button_image(panel, "Kill View", 0, 0),
X PANEL_NOTIFY_PROC, kill_view_proc,
X 0);
X window_fit(panel);
X window_fit_width(frame);
X
X subframe_ptr->textsw = 0;
X subframe_ptr->props = 0;
X
X subframe_ptr->canvas = window_create(frame, CANVAS,
X CANVAS_REPAINT_PROC, repaint_canvas,
X CANVAS_FIXED_IMAGE, FALSE,
X CANVAS_RETAINED, FALSE,
X WIN_BELOW, panel,
X WIN_WIDTH, (int) window_get(frame, WIN_WIDTH, 0),
X WIN_HEIGHT, (int) window_get(frame, WIN_WIDTH, 0),
X WIN_EVENT_PROC, zoom_event,
X WIN_CLIENT_DATA, subframe_ptr,
X 0);
X repaint_canvas(subframe_ptr->canvas);
X
X window_fit(frame);
X
X /* Add menu item to base frame to re-create base panel */
X menu = window_get(frame, WIN_MENU);
X menu_item = menu_create_item(MENU_STRING, "Re-create panel",
X MENU_INACTIVE, TRUE,
X MENU_ACTION_PROC, make_panel,
X 0);
X subframe_ptr->menu_item = menu_item;
X menu_set(menu, MENU_APPEND_ITEM, menu_item, 0);
X menu_set(menu_item, MENU_INACTIVE, TRUE, 0); /* Don't show it yet */
X
X /* Turn it on. */
X window_set(subframe_ptr->canvas, WIN_SHOW, TRUE, 0);
X window_set(frame, WIN_SHOW, TRUE, 0);
X
X /* Check to see if we are at the limit of subframes */
X if (num_of_subframes == MAX_SUBFRAMES - 1) {
X panel_set(view_button, PANEL_SHOW_ITEM, FALSE, 0);
X }
X if (num_fd + 3 > MAX_FD)
X panel_set(view_button, PANEL_SHOW_ITEM, FALSE, 0);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < make_sub.c` -ne 155; then
echo -n 'shar: make_sub.c was damaged during transit'
echo ' (should have been 155 bytes)'
fi
fi ; : end of overwriting check
echo 'x - pipe_reader.c'
if test -f pipe_reader.c
then echo 'shar: not overwriting pipe_reader.c'; else
sed 's/^X//' << '________This_Is_The_END________' > pipe_reader.c
X#include <stdio.h>
X#include <math.h>
X#include "trackertool.h"
X
XNotify_value
Xpipe_reader(unique_handle, fd)
X int *unique_handle;
X int fd;
X{
X /*
X * pipe_reader is called when there is input pending. It reads in
X * the data. It also fakes an array value for the line number in
X * Array[num_arrays].
X */
X int offset;
X int i, j;
X int EOF_there;
X static char string[26] = {"End of data: Values: 0"};
X
X void get_axis_bounds(), get_axis_log_bounds();
X void update_arrays(), update_displays();
X void rewrite_text();
X float newmin, newmax, newmin_log;
X
X /* Check to see if we have too many values */
X if (++num_values == MAX_VALUES) {
X offset = MAX_VALUES / 2;
X for (i = 0; i <= num_arrays; i++) {
X newmin = array_ptr[i]->values[0 + offset];
X newmax = array_ptr[i]->values[0 + offset];
X if (array_ptr[i]->values[0 + offset] > 0.)
X newmin_log = array_ptr[i]->values[0 + offset];
X else
X newmin_log = 0.;
X for (j = 0; j < offset; j++) {
X array_ptr[i]->values[j] = array_ptr[i]->values[j + offset];
X array_ptr[i]->log_values[j] =
X array_ptr[i]->log_values[j + offset];
X if (array_ptr[i]->values[j] < newmin)
X newmin = array_ptr[i]->values[j];
X if (array_ptr[i]->values[j] > newmax)
X newmax = array_ptr[i]->values[j];
X if ((array_ptr[i]->values[j] < newmin_log || newmin_log == 0.)
X && array_ptr[i]->values[j] > 0.)
X newmin_log = array_ptr[i]->values[j];
X }
X array_ptr[i]->min_value = newmin;
X array_ptr[i]->max_value = newmax;
X get_axis_bounds(array_ptr[i]->min_value, array_ptr[i]->max_value,
X &(array_ptr[i]->min_graph), &(array_ptr[i]->max_graph));
X array_ptr[i]->min_value_log = newmin_log;
X get_axis_log_bounds(
X array_ptr[i]->min_value_log, array_ptr[i]->max_value,
X &(array_ptr[i]->min_graph_log), &(array_ptr[i]->max_graph_log));
X }
X num_values = j;
X
X /*
X * Also, the textsw's can only hold so much. Check to see if
X * they are holding more than 4 sets of values. If so, reset
X * them to only hold the last. This 4 is set in
X * TEXTSW_MEMORY_MAXIMUM, in display_mode_proc().
X */
X for (i = 0; i <= num_of_subframes; i++) {
X if (subframe[i]->textsw)
X if ((int) window_get(subframe[i]->textsw, TEXTSW_LENGTH, 0)
X > 21 * MAX_VALUES * 4)
X rewrite_text(subframe[i]->textsw);
X }
X }
X /* Read in subsequent arrays from input */
X for (i = 0; i < num_arrays; i++) {
X EOF_there = scanf("%f", &(array_ptr[i]->values[num_values]));
X if (EOF_there != EOF) {
X if (echo_on)
X printf("%f ", array_ptr[i]->values[num_values]);
X if (array_ptr[i]->values[num_values] > 0)
X array_ptr[i]->log_values[num_values] =
X log10((double) array_ptr[i]->values[num_values]);
X else
X array_ptr[i]->log_values[num_values] = 0.;
X }
X }
X scanf("%*[^\n]"); /* skip over extra data until newline */
X if (echo_on)
X printf("\n", array_ptr[i]->values[num_values]);
X
X
X if (EOF_there == EOF) { /* No more data left. Reset input
X * handler and main panel label */
X notify_set_input_func(unique_handle, NOTIFY_FUNC_NULL, 0);
X sprintf(&string[21], "%4d", num_values--);
X panel_set(num_message, PANEL_LABEL_STRING, string, 0);
X return (NOTIFY_DONE);
X }
X /* Last array is just record number */
X array_ptr[num_arrays]->values[num_values] = num_values + 1;
X array_ptr[num_arrays]->log_values[num_values] =
X log10((double) num_values + 1);
X
X /* Now update the graphs */
X update_arrays();
X update_displays();
X
X return (NOTIFY_DONE);
X}
________This_Is_The_END________
if test `wc -l < pipe_reader.c` -ne 106; then
echo -n 'shar: pipe_reader.c was damaged during transit'
echo ' (should have been 106 bytes)'
fi
fi ; : end of overwriting check
echo 'x - quit_proc.c'
if test -f quit_proc.c
then echo 'shar: not overwriting quit_proc.c'; else
sed 's/^X//' << '________This_Is_The_END________' > quit_proc.c
X#include "trackertool.h"
X
Xint client; /* handle for input control */
Xvoid
Xquit_proc(button, event)
X Panel_item button;
X Event *event;
X /* Simply kills everything and leaves, or hides. */
X{
X int window_done();
X int i;
X Notify_value pipe_reader();
X
X /* Turn off input notification (it causes asynch trouble */
X notify_set_input_func(&client, NOTIFY_FUNC_NULL, 0);
X
X /* Nice knowing ya */
X if (!window_done(main_panel)) { /* destroy may be vetoed */
X notify_set_input_func(&client, pipe_reader, 0);
X return;
X }
X /* If button was Quit, just leave. Quickly. */
X if (button == quit_button)
X exit(0);
X
X /*
X * Replace process with a simple cat. Since Sunview needs to clean
X * up, I can't very well just execl() quite yet. Do a fork() and
X * execl()/return.
X */
X if (fork() == 0)
X return; /* allow Sunview to cleanup
X * on return to main() */
X
X /*
X * The parent has gone home to clean up. Let's keep the output
X * going.
X */
X if (echo_on)
X execl("/bin/cat", "cat", "-", 0);
X else
X execl("/bin/sh", "sh", "-c", "cat - > /dev/null", 0);
X
X /* This function should never go anywhere after this,
X * even if the execl fails.
X */
X exit(0);
X}
________This_Is_The_END________
if test `wc -l < quit_proc.c` -ne 48; then
echo -n 'shar: quit_proc.c was damaged during transit'
echo ' (should have been 48 bytes)'
fi
fi ; : end of overwriting check
echo 'x - repaint_canvas.c'
if test -f repaint_canvas.c
then echo 'shar: not overwriting repaint_canvas.c'; else
sed 's/^X//' << '________This_Is_The_END________' > repaint_canvas.c
X#include <stdio.h>
X#include <string.h>
X#include <math.h>
X#include "trackertool.h"
X
Xvoid
Xrepaint_canvas(canvas)
X Canvas canvas;
X{
X Pixwin *pw;
X Subframe *subframe_ptr;
X Array *x_ptr, *y_ptr;
X
X /* Raster units */
X int i, ix, iy, jx, jy;
X int x_axis_min, x_axis_max, y_axis_min, y_axis_max;
X int width, height;
X int grid_line;
X
X float x_scale, y_scale; /* coordinate to raster
X * conversion */
X float *x_value_ptr, *y_value_ptr;
X
X /* Coordinate units */
X float x_min_graph, x_max_graph, y_min_graph, y_max_graph;
X float grid_min, grid_max, grid_delta, grid, grid_log_switch;
X
X void get_grid_bounds();
X void get_grid_log_bounds();
X
X /* Axis label strings */
X char lab_x_min[15], lab_x_max[15], lab_y_min[15], lab_y_max[15];
X int len_x_min, len_x_max, len_y_min, len_y_max;
X int box_x, box_y; /* font sizes */
X struct pixfont *pf_used; /* font for axis labels */
X static struct pixfont *pf_small, *pf_medium, *pf_large; /* keep fonts */
X
X
X if (canvas == 0)
X return; /* canvas is not there */
X pw = canvas_pixwin(canvas); /* get the pixwin to draw into */
X
X /* Find the subframe and x, y arrays for this canvas */
X subframe_ptr = (Subframe *) window_get(canvas, WIN_CLIENT_DATA, 0);
X x_ptr = subframe_ptr->x;
X y_ptr = subframe_ptr->y;
X
X /* get current canvas dimensions */
X width = (int) window_get(canvas, CANVAS_WIDTH);
X height = (int) window_get(canvas, CANVAS_HEIGHT);
X
X /*
X * Scale the axis label size to the dimensions. Some ugly magic
X * numbers here, but hey, what do you want?
X */
X if (width < 150) {
X if (pf_small == NULL)
X pf_small = pf_open("/usr/lib/fonts/fixedwidthfonts/screen.r.7");
X pf_used = pf_small;
X box_x = pf_small->pf_defaultsize.x;
X box_y = pf_small->pf_defaultsize.y + 2;
X } else if (width < 350) {
X if (pf_medium == NULL)
X pf_medium = pf_open("/usr/lib/fonts/fixedwidthfonts/screen.r.11");
X pf_used = pf_medium;
X box_x = pf_medium->pf_defaultsize.x;
X box_y = pf_medium->pf_defaultsize.y + 2;
X } else {
X if (pf_large == NULL)
X pf_large = pf_open("/usr/lib/fonts/fixedwidthfonts/gallant.r.19");
X pf_used = pf_large;
X box_x = pf_large->pf_defaultsize.x;
X box_y = pf_large->pf_defaultsize.y + 2;
X }
X
X /* Clear the canvas */
X pw_writebackground(pw, 0, 0, width, height, PIX_SRC);
X
X /*
X * Find new axis limits for the auto limits. The axis limits might
X * have changed between redraws, or they might be fixed by the
X * panel when _auto turned off
X */
X if (subframe_ptr->x_log) {
X if (subframe_ptr->x_min_auto)
X subframe_ptr->x_min = x_ptr->min_graph_log;
X if (subframe_ptr->x_max_auto)
X subframe_ptr->x_max = x_ptr->max_graph_log;
X } else {
X if (subframe_ptr->x_min_auto)
X subframe_ptr->x_min = x_ptr->min_graph;
X if (subframe_ptr->x_max_auto)
X subframe_ptr->x_max = x_ptr->max_graph;
X }
X if (subframe_ptr->y_log) {
X if (subframe_ptr->y_min_auto)
X subframe_ptr->y_min = y_ptr->min_graph_log;
X if (subframe_ptr->y_max_auto)
X subframe_ptr->y_max = y_ptr->max_graph_log;
X } else {
X if (subframe_ptr->y_min_auto)
X subframe_ptr->y_min = y_ptr->min_graph;
X if (subframe_ptr->y_max_auto)
X subframe_ptr->y_max = y_ptr->max_graph;
X }
X /* get the axis labels and lengths in pixels */
X len_x_min = strlen(gcvt(subframe_ptr->x_min, 5, lab_x_min)) * box_x + 2;
X len_x_max = strlen(gcvt(subframe_ptr->x_max, 5, lab_x_max)) * box_x + 2;
X len_y_min = strlen(gcvt(subframe_ptr->y_min, 5, lab_y_min)) * box_x + 2;
X len_y_max = strlen(gcvt(subframe_ptr->y_max, 5, lab_y_max)) * box_x + 2;
X
X /* Find axis limits in pixels and draw them */
X x_axis_min = (len_y_min > len_y_max) ? len_y_min : len_y_max;
X x_axis_min = (len_x_min / 2 > x_axis_min) ? len_x_min / 2 : x_axis_min;
X x_axis_max = width - 2;
X y_axis_min = height - box_y - 3;
X y_axis_max = 2;
X pw_vector(pw, x_axis_min, y_axis_max, x_axis_min, y_axis_min, PIX_SRC, 1);
X pw_vector(pw, x_axis_min, y_axis_min, x_axis_max, y_axis_min, PIX_SRC, 1);
X subframe_ptr->x_axis_min = x_axis_min;
X subframe_ptr->x_axis_max = x_axis_max;
X subframe_ptr->y_axis_min = y_axis_min;
X subframe_ptr->y_axis_max = y_axis_max;
X
X /* Put the new axis limits on the canvas */
X pw_text(pw, x_axis_min - len_x_min / 2, y_axis_min + box_y,
X PIX_SRC, pf_used, lab_x_min);
X pw_text(pw, x_axis_max - len_x_max, y_axis_min + box_y,
X PIX_SRC, pf_used, lab_x_max);
X pw_text(pw, x_axis_min - len_y_min, y_axis_min,
X PIX_SRC, pf_used, lab_y_min);
X pw_text(pw, x_axis_min - len_y_max, y_axis_max + box_y - 2,
X PIX_SRC, pf_used, lab_y_max);
X
X /* If control panel not there, put axis label on canvas */
X if (!subframe_ptr->panel) {
X pw_text(pw, width / 2, y_axis_min + box_y,
X PIX_SRC, pf_used, x_ptr->label_l);
X pw_text(pw, width / 2, y_axis_max + box_y - 2,
X PIX_SRC, pf_used, y_ptr->label_l);
X }
X /*
X * finalize linear, log axis limits here. Also, set up the
X * pointers to the array values.
X */
X if (subframe_ptr->x_log) {
X if (subframe_ptr->x_min <= 0.) {
X pw_text(pw, width / 5, height / 5, PIX_SRC, NULL,
X "x_min < 0; Log invalid");
X return;
X }
X x_value_ptr = x_ptr->log_values;
X x_min_graph = log10(subframe_ptr->x_min);
X x_max_graph = log10(subframe_ptr->x_max);
X } else {
X x_value_ptr = x_ptr->values;
X x_min_graph = subframe_ptr->x_min;
X x_max_graph = subframe_ptr->x_max;
X }
X if (subframe_ptr->y_log) {
X if (subframe_ptr->y_min <= 0.) {
X pw_text(pw, width / 5, height / 5, PIX_SRC, NULL,
X "y_min < 0; Log invalid");
X return;
X }
X y_value_ptr = y_ptr->log_values;
X y_min_graph = log10(subframe_ptr->y_min);
X y_max_graph = log10(subframe_ptr->y_max);
X } else {
X y_value_ptr = y_ptr->values;
X y_min_graph = subframe_ptr->y_min;
X y_max_graph = subframe_ptr->y_max;
X }
X
X /* Draw the actual data now */
X x_scale = (x_axis_max - x_axis_min) / (x_max_graph - x_min_graph);
X y_scale = (y_axis_max - y_axis_min) / (y_max_graph - y_min_graph);
X ix = (*x_value_ptr - x_min_graph) * x_scale + x_axis_min;
X iy = (*y_value_ptr - y_min_graph) * y_scale + y_axis_min;
X
X pw_batch_on(pw);
X
X for (i = subframe_ptr->connect_points; i <= num_values; i++) {
X jx = (*(++x_value_ptr) - x_min_graph) * x_scale + x_axis_min;
X jy = (*(++y_value_ptr) - y_min_graph) * y_scale + y_axis_min;
X
X if (subframe_ptr->connect_points) {
X pw_vector(pw, ix, iy, jx, jy, PIX_SRC, 1);
X ix = jx;
X iy = jy;
X } else
X pw_put(pw, jx, jy, 1);
X
X }
X
X /* Draw x grid */
X if (subframe_ptr->x_grid) {
X if (subframe_ptr->x_log) { /* Logarithmic grid lines */
X get_grid_log_bounds(x_min_graph, x_max_graph,
X &grid_min, &grid_max, &grid_delta, &grid_log_switch);
X for (grid = grid_min; grid < grid_max; grid = grid + grid_delta) {
X if (grid > grid_log_switch) { /* Need to change grid
X * spacing */
X grid_delta *= 10.;
X grid = 2. * grid_delta;
X grid_log_switch *= 10.;
X }
X grid_line = (log10(grid) - x_min_graph) * x_scale
X + x_axis_min + 0.5;
X pw_vector(pw, grid_line, y_axis_min,
X grid_line, y_axis_max, PIX_SRC, 1);
X }
X } else { /* Normal grid lines */
X get_grid_bounds(x_min_graph, x_max_graph,
X &grid_min, &grid_max, &grid_delta);
X for (grid = grid_min; grid < grid_max; grid = grid + grid_delta) {
X grid_line = (grid - x_min_graph) * x_scale + x_axis_min + 0.5;
X pw_vector(pw, grid_line, y_axis_min,
X grid_line, y_axis_max, PIX_SRC, 1);
X }
X }
X }
X /* Draw y grid */
X if (subframe_ptr->y_grid) {
X if (subframe_ptr->y_log) { /* Logarithmic grid lines */
X get_grid_log_bounds(y_min_graph, y_max_graph,
X &grid_min, &grid_max, &grid_delta, &grid_log_switch);
X for (grid = grid_min; grid < grid_max; grid = grid + grid_delta) {
X if (grid > grid_log_switch) { /* Need to change grid
X * spacing */
X grid_delta *= 10.;
X grid = 2. * grid_delta;
X grid_log_switch *= 10.;
X }
X grid_line = (log10(grid) - y_min_graph) * y_scale
X + y_axis_min + 0.5;
X pw_vector(pw, x_axis_min, grid_line,
X x_axis_max, grid_line, PIX_SRC, 1);
X }
X } else { /* Normal grid lines */
X get_grid_bounds(y_min_graph, y_max_graph,
X &grid_min, &grid_max, &grid_delta);
X for (grid = grid_min; grid < grid_max; grid = grid + grid_delta) {
X grid_line = (grid - y_min_graph) * y_scale + y_axis_min + 0.5;
X pw_vector(pw, x_axis_min, grid_line,
X x_axis_max, grid_line, PIX_SRC, 1);
X }
X }
X }
X pw_batch_off(pw);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < repaint_canvas.c` -ne 253; then
echo -n 'shar: repaint_canvas.c was damaged during transit'
echo ' (should have been 253 bytes)'
fi
fi ; : end of overwriting check
echo 'x - reset_axis_proc.c'
if test -f reset_axis_proc.c
then echo 'shar: not overwriting reset_axis_proc.c'; else
sed 's/^X//' << '________This_Is_The_END________' > reset_axis_proc.c
X#include "trackertool.h"
X
Xvoid
Xreset_axis_proc(button)
X Panel_item button;
X/*
X * On reset: resets the axis descriptors to the default values
X * On redraw: get the panel's text strings and redraw
X */
X{
X Panel panel;
X Subframe *subframe_ptr;
X Panel_item next_item;
X void repaint_canvas();
X double atof();
X
X panel = (Panel) panel_get(button, PANEL_PARENT_PANEL);
X subframe_ptr = (Subframe *) window_get(panel, WIN_CLIENT_DATA, 0);
X
X if ((int) panel_get(button, PANEL_CLIENT_DATA)) {
X subframe_ptr->x_min_auto = TRUE;
X subframe_ptr->x_max_auto = TRUE;
X subframe_ptr->x_log = FALSE;
X subframe_ptr->x_grid = FALSE;
X subframe_ptr->y_min_auto = TRUE;
X subframe_ptr->y_max_auto = TRUE;
X subframe_ptr->y_log = FALSE;
X subframe_ptr->y_grid = FALSE;
X subframe_ptr->connect_points = TRUE;
X
X /* reset the panel: draw mode, and x,y atributes */
X next_item = window_get(panel, PANEL_FIRST_ITEM, 0);
X panel_set_value(next_item, TRUE); /* draw mode to connect */
X next_item = panel_get(next_item, PANEL_NEXT_ITEM, 0);
X panel_set_value(next_item, 3); /* x attributes */
X next_item = panel_get(next_item, PANEL_NEXT_ITEM, 0);
X panel_set_value(next_item, 3); /* y attributes */
X } else {
X /* get the panel values again if redraw requested */
X if (!subframe_ptr->x_min_auto)
X subframe_ptr->x_min = atof(
X (char *) panel_get_value(subframe_ptr->props_x_min));
X if (!subframe_ptr->x_max_auto)
X subframe_ptr->x_max = atof(
X (char *) panel_get_value(subframe_ptr->props_x_max));
X if (!subframe_ptr->y_min_auto)
X subframe_ptr->y_min = atof(
X (char *) panel_get_value(subframe_ptr->props_y_min));
X if (!subframe_ptr->y_max_auto)
X subframe_ptr->y_max = atof(
X (char *) panel_get_value(subframe_ptr->props_y_max));
X }
X
X repaint_canvas(subframe_ptr->canvas);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < reset_axis_proc.c` -ne 57; then
echo -n 'shar: reset_axis_proc.c was damaged during transit'
echo ' (should have been 57 bytes)'
fi
fi ; : end of overwriting check
echo 'x - rewrite_text.c'
if test -f rewrite_text.c
then echo 'shar: not overwriting rewrite_text.c'; else
sed 's/^X//' << '________This_Is_The_END________' > rewrite_text.c
X#include <string.h>
X#include "trackertool.h"
X
Xvoid
Xrewrite_text(textsw)
X Textsw textsw;
X{
X /*
X * rewrite_text will create a new text from scratch. It will delete
X * whatever text is already there, which is needed in the case of
X * variable changes.
X */
X Subframe *subframe_ptr;
X char string[2 * MAX_STR_LEN + 4];
X char *buffer, *buf_counter;
X int i;
X
X if (textsw == 0)
X return; /* textsw is not there */
X
X /* Find the subframe we're in */
X subframe_ptr = (Subframe *) window_get(textsw, WIN_CLIENT_DATA, 0);
X
X textsw_reset(textsw, 0, 0); /* Delete current text */
X
X /* Construct label line */
X strncpy(&string[0], " ", 2);
X strncpy(&string[2], subframe_ptr->x->label_r, MAX_STR_LEN - 1);
X strncpy(&string[MAX_STR_LEN + 1], " ", 3);
X strncpy(&string[MAX_STR_LEN + 4], subframe_ptr->y->label_r,
X MAX_STR_LEN - 1);
X textsw_insert(textsw, string, 2 * MAX_STR_LEN + 3);
X
X /*
X * Now put in the data. We allocate a buffer big enough for all
X * the characters, place them in, and hand it to textsw_insert.
X * This is much faster than multiple inserts.
X */
X buffer = (char *) malloc(26 * (num_values + 1) * sizeof(char));
X buf_counter = buffer;
X for (i = 0; i <= num_values; i++) {
X sprintf(buf_counter, "\n%12g %12g",
X subframe_ptr->x->values[i], subframe_ptr->y->values[i]);
X buf_counter += 26;
X }
X textsw_insert(textsw, buffer, 26 * (num_values + 1));
X free(buffer);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < rewrite_text.c` -ne 50; then
echo -n 'shar: rewrite_text.c was damaged during transit'
echo ' (should have been 50 bytes)'
fi
fi ; : end of overwriting check
echo 'x - trackertool.c'
if test -f trackertool.c
then echo 'shar: not overwriting trackertool.c'; else
sed 's/^X//' << '________This_Is_The_END________' > trackertool.c
X#include "stdio.h"
X#include "trackertool.h"
X
X/* Trackertool, Version 1.0, November 1988
X *
X *
X * Copyright (c) 1988 Roy Richter, GM Corp. Anyone can use this
X * software in any manner they choose, including copying, modification
X * and redistribution, provided they make no charge for it, the source
X * code is included in the distribution, and these conditions remain
X * unchanged.
X
X *
X * This program is distributed as is, with all faults (if any), and
X * without any warranty. No author or distributor accepts responsibility
X * to anyone for the consequences of using it, or for whether it serves
X * any particular purpose at all, or any other reason.
X *
X */
X
Xint client; /* handle for input control */
X
Xmain(argc, argv)
X int argc;
X char **argv;
X{
X Frame make_base(), base_frame;
X void make_labels();
X Notify_value pipe_reader();
X
X int process_group;
X
X int c; /* to hold arguments from getopt */
X extern int opterr; /* getopt's error checking */
X extern char *optarg; /* getopt's return value */
X
X /*
X * I'm keeping track of the file descriptors to prevent overusage.
X * This is the real limit to the number of open windows. 3 (unix)
X * +1 (framebuffer) +4 (selection service) +1 (window manager) +1
X * (good luck)
X */
X num_fd = 10;
X
X /* get the command line arguments, if any. */
X opterr = 0; /* ignore options we don't recognize */
X MAX_VALUES = DEFAULT_MAX_VALUES; /* set defaults */
X echo_on = TRUE; /* echo input to output */
X while ((c = getopt(argc, argv, "nv:")) != EOF)
X switch (c) {
X case 'v': /* increase MAX_VALUES */
X MAX_VALUES = atoi(optarg);
X if (MAX_VALUES < 2 || MAX_VALUES > 100000) {
X fprintf(stderr, "-v %s = %d out of range.\n",
X optarg, MAX_VALUES);
X fprintf(stderr, "Allowable range is 2 to 100,000. ");
X fprintf(stderr, "Defaulting to %d.\n", DEFAULT_MAX_VALUES);
X MAX_VALUES = DEFAULT_MAX_VALUES;
X }
X break;
X case 'n': /* don't echo input to output */
X echo_on = FALSE;
X break;
X case '?':
X break; /* ignore others */
X }
X
X /*
X * get the current process group. It needs to be reset after each
X * window_create to allow dbxtool to work.
X */
X process_group = getpgrp(0);
X
X /* Create the base frame window */
X base_frame = make_base(argc, argv);
X
X /* now set the process group */
X setpgrp(0, process_group);
X
X /* Get the label line from stdin and initialize labels */
X make_labels();
X
X /* Tell the notifier what to do when input is received */
X (void) notify_set_input_func(&client, pipe_reader, 0);
X
X /*
X * Start notifier to grab button pushes, etc. We return from this
X * call when quit is pressed. and quit_proc is called.
X */
X window_main_loop(base_frame);
X}
________This_Is_The_END________
if test `wc -l < trackertool.c` -ne 91; then
echo -n 'shar: trackertool.c was damaged during transit'
echo ' (should have been 91 bytes)'
fi
fi ; : end of overwriting check
echo 'x - update_arrays.c'
if test -f update_arrays.c
then echo 'shar: not overwriting update_arrays.c'; else
sed 's/^X//' << '________This_Is_The_END________' > update_arrays.c
X#include "trackertool.h"
X
Xvoid
Xupdate_arrays()
X{
X /* updates the array tables when a new value is added */
X int i;
X float value;
X
X void get_axis_bounds();
X void get_axis_log_bounds();
X
X /*
X * Update the actual min, max values; and then check to see if we
X * need to change the graph limits
X */
X if (num_values) /* Not first time through? */
X for (i = 0; i <= num_arrays; i++) {
X value = array_ptr[i]->values[num_values];
X
X /* Update min, max values and possibly axis limits */
X if (array_ptr[i]->min_value > value)
X array_ptr[i]->min_value = value;
X if (array_ptr[i]->max_value < value)
X array_ptr[i]->max_value = value;
X if (array_ptr[i]->min_value < array_ptr[i]->min_graph ||
X array_ptr[i]->max_value > array_ptr[i]->max_graph)
X get_axis_bounds(array_ptr[i]->min_value,
X array_ptr[i]->max_value,
X &(array_ptr[i]->min_graph),
X &(array_ptr[i]->max_graph));
X
X /* keep minimum positive value for log bound */
X if ((array_ptr[i]->min_value_log > value ||
X array_ptr[i]->min_value_log == 0) && value > 0.)
X array_ptr[i]->min_value_log = value;
X if (array_ptr[i]->min_value_log < array_ptr[i]->min_graph_log ||
X array_ptr[i]->max_value > array_ptr[i]->max_graph_log)
X get_axis_log_bounds(array_ptr[i]->min_value_log,
X array_ptr[i]->max_value,
X &(array_ptr[i]->min_graph_log),
X &(array_ptr[i]->max_graph_log));
X }
X else
X /* case for num_values = 0; this is first time through */
X for (i = 0; i <= num_arrays; i++) {
X value = array_ptr[i]->values[num_values];
X array_ptr[i]->min_value = value;
X array_ptr[i]->max_value = value;
X array_ptr[i]->min_graph = value;
X array_ptr[i]->max_value = value;
X if (value > 0.) {
X array_ptr[i]->min_value_log = value;
X array_ptr[i]->min_graph_log = value;
X array_ptr[i]->max_graph_log = value;
X } else {
X array_ptr[i]->min_value_log = 0.;
X array_ptr[i]->min_graph_log = 1e22;
X array_ptr[i]->max_graph_log = 1e-22;
X }
X }
X
X return;
X}
________This_Is_The_END________
if test `wc -l < update_arrays.c` -ne 64; then
echo -n 'shar: update_arrays.c was damaged during transit'
echo ' (should have been 64 bytes)'
fi
fi ; : end of overwriting check
echo 'x - update_canvas.c'
if test -f update_canvas.c
then echo 'shar: not overwriting update_canvas.c'; else
sed 's/^X//' << '________This_Is_The_END________' > update_canvas.c
X#include <math.h>
X#include "trackertool.h"
X
Xvoid
Xupdate_canvas(canvas)
X Canvas canvas;
X /* Adds a line segment to the given canvas */
X{
X Pixwin *pw;
X Subframe *subframe_ptr;
X Array *x_ptr, *y_ptr;
X
X int ix, iy, jx, jy;
X int x_axis_min, x_axis_max, y_axis_min, y_axis_max;
X float x_scale, y_scale;
X float *x_value_ptr, *y_value_ptr;
X float x_min_graph, x_max_graph, y_min_graph, y_max_graph;
X
X if (num_values == 0)
X return; /* can't draw one point */
X if (canvas == 0)
X return; /* canvas is not there */
X
X /* Get the pixwin to draw into */
X pw = canvas_pixwin(canvas);
X
X /* Find the subframe and x, y arrays for this canvas */
X subframe_ptr = (Subframe *) window_get(canvas, WIN_CLIENT_DATA, 0);
X x_ptr = subframe_ptr->x;
X y_ptr = subframe_ptr->y;
X
X /* Find axis limits */
X x_axis_min = subframe_ptr->x_axis_min;
X x_axis_max = subframe_ptr->x_axis_max;
X y_axis_min = subframe_ptr->y_axis_min;
X y_axis_max = subframe_ptr->y_axis_max;
X
X if (subframe_ptr->x_log) {
X x_value_ptr = &(x_ptr->log_values[num_values - 1]);
X x_min_graph = log10(subframe_ptr->x_min);
X x_max_graph = log10(subframe_ptr->x_max);
X } else {
X x_value_ptr = &(x_ptr->values[num_values - 1]);
X x_min_graph = subframe_ptr->x_min;
X x_max_graph = subframe_ptr->x_max;
X }
X if (subframe_ptr->y_log) {
X y_value_ptr = &(y_ptr->log_values[num_values - 1]);
X y_min_graph = log10(subframe_ptr->y_min);
X y_max_graph = log10(subframe_ptr->y_max);
X } else {
X y_value_ptr = &(y_ptr->values[num_values - 1]);
X y_min_graph = subframe_ptr->y_min;
X y_max_graph = subframe_ptr->y_max;
X }
X
X /* Draw the actual data now */
X x_scale = (x_axis_max - x_axis_min) / (x_max_graph - x_min_graph);
X y_scale = (y_axis_max - y_axis_min) / (y_max_graph - y_min_graph);
X
X ix = (*(x_value_ptr++) - x_min_graph) * x_scale + x_axis_min;
X iy = (*(y_value_ptr++) - y_min_graph) * y_scale + y_axis_min;
X jx = (*x_value_ptr - x_min_graph) * x_scale + x_axis_min;
X jy = (*y_value_ptr - y_min_graph) * y_scale + y_axis_min;
X
X if (subframe_ptr->connect_points)
X pw_vector(pw, ix, iy, jx, jy, PIX_SRC, 1);
X else
X pw_put(pw, jx, jy, 1);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < update_canvas.c` -ne 72; then
echo -n 'shar: update_canvas.c was damaged during transit'
echo ' (should have been 72 bytes)'
fi
fi ; : end of overwriting check
echo 'x - update_displays.c'
if test -f update_displays.c
then echo 'shar: not overwriting update_displays.c'; else
sed 's/^X//' << '________This_Is_The_END________' > update_displays.c
X#include <stdio.h>
X#include "trackertool.h"
X
Xvoid
Xupdate_displays()
X/* update_displays will incrementally update the displays in progress
X */
X{
X void update_textsw();
X void update_canvas();
X void repaint_canvas();
X
X static char string[26] = {"Reading..... Values: 0"};
X float x_min, x_max, y_min, y_max;
X Subframe *subframe_ptr, **sub_ptr_ptr, **sub_ptr_max;
X
X sprintf(&string[21], "%4d", num_values + 1);
X panel_set(num_message, PANEL_LABEL_STRING, string, 0);
X
X sub_ptr_max = subframe + num_of_subframes;
X for (sub_ptr_ptr = subframe; sub_ptr_ptr <= sub_ptr_max; sub_ptr_ptr++) {
X subframe_ptr = *sub_ptr_ptr;
X update_textsw(subframe_ptr->textsw);
X
X /* {x,y}_{min,max} contains the current array limits. */
X if (subframe_ptr->x_log) {
X x_min = subframe_ptr->x->min_graph_log;
X x_max = subframe_ptr->x->max_graph_log;
X } else {
X x_min = subframe_ptr->x->min_graph;
X x_max = subframe_ptr->x->max_graph;
X }
X if (subframe_ptr->y_log) {
X y_min = subframe_ptr->y->min_graph_log;
X y_max = subframe_ptr->y->max_graph_log;
X } else {
X y_min = subframe_ptr->y->min_graph;
X y_max = subframe_ptr->y->max_graph;
X }
X
X /* test here to see if we need to rescale the axis limits */
X if ((x_min < subframe_ptr->x_min && subframe_ptr->x_min_auto) ||
X (x_max > subframe_ptr->x_max && subframe_ptr->x_max_auto) ||
X (y_min < subframe_ptr->y_min && subframe_ptr->y_min_auto) ||
X (y_max > subframe_ptr->y_max && subframe_ptr->y_max_auto))
X repaint_canvas(subframe_ptr->canvas);
X else
X update_canvas(subframe_ptr->canvas);
X }
X
X return;
X}
________This_Is_The_END________
if test `wc -l < update_displays.c` -ne 52; then
echo -n 'shar: update_displays.c was damaged during transit'
echo ' (should have been 52 bytes)'
fi
fi ; : end of overwriting check
echo 'x - update_textsw.c'
if test -f update_textsw.c
then echo 'shar: not overwriting update_textsw.c'; else
sed 's/^X//' << '________This_Is_The_END________' > update_textsw.c
X#include <stdio.h>
X#include "trackertool.h"
X
Xvoid
Xupdate_textsw(textsw)
X Textsw textsw;
X/* Add a line to the given textsw */
X{
X Subframe *subframe_ptr;
X char string[2 * MAX_STR_LEN + 4];
X
X if (textsw == 0)
X return; /* textsw is not there */
X
X /* Find the subframe we're in */
X subframe_ptr = (Subframe *) window_get(textsw, WIN_CLIENT_DATA, 0);
X
X /* Construct line */
X sprintf(string, "\n%12g %12g", subframe_ptr->x->values[num_values],
X subframe_ptr->y->values[num_values]);
X
X /* Insert the line at the current insertion point */
X textsw_insert(textsw, string, 2 * MAX_STR_LEN + 4);
X
X return;
X}
________This_Is_The_END________
if test `wc -l < update_textsw.c` -ne 26; then
echo -n 'shar: update_textsw.c was damaged during transit'
echo ' (should have been 26 bytes)'
fi
fi ; : end of overwriting check
echo 'x - zoom_event.c'
if test -f zoom_event.c
then echo 'shar: not overwriting zoom_event.c'; else
sed 's/^X//' << '________This_Is_The_END________' > zoom_event.c
X#include "trackertool.h"
X#include <math.h>
X
XNotify_value
Xzoom_event(canvas, event)
X Canvas canvas;
X Event *event;
X{
X /*
X * zoom_event is used to zoom the picture in a graph It picks up
X * the events turned on when th canvas was created You put the left
X * button down, and rectangle is created; as the mouse is moved,
X * the rectangle follows the mouse; when the buttonis released, the
X * final bounding coordinates are used to reset the axis bounds.
X */
X Pixwin *pw;
X static int x0, y0, x1, y1;
X static int box_started = FALSE;
X int id;
X void make_box(), set_axis_bounds();
X
X id = event_id(event);
X pw = canvas_pixwin(canvas);
X
X /* Follow the bounding box, if started */
X if (id == LOC_MOVE && box_started) {
X make_box(pw, x0, y0, x1, y1);
X x1 = event_x(event);
X y1 = event_y(event);
X make_box(pw, x0, y0, x1, y1);
X return;
X }
X /* Only the left button is active */
X if (id != MS_LEFT)
X return;
X
X /* The initial button push is caught here */
X if (event_is_down(event) && !box_started) {
X x0 = event_x(event);
X y0 = event_y(event);
X x1 = x0;
X y1 = y0;
X make_box(pw, x0, y0, x1, y1);
X box_started = TRUE;
X return;
X }
X /* Final button release is caught here */
X if (event_is_up(event) && box_started) {
X make_box(pw, x0, y0, x1, y1);
X x1 = event_x(event);
X y1 = event_y(event);
X box_started = FALSE;
X set_axis_bounds(canvas, x0, y1, x1, y0);
X return;
X }
X return;
X}
X
Xvoid
Xmake_box(pw, x0, y0, x1, y1)
X Pixwin *pw;
X int x0, y0, x1, y1;
X{
X /*
X * make_box will invert the pixels given in the bounding box. Use
X * it to write and erase a rubber-band box from make_box.
X */
X pw_vector(pw, x0, y0, x1, y0, PIX_NOT(PIX_DST), 1);
X pw_vector(pw, x1, y0, x1, y1, PIX_NOT(PIX_DST), 1);
X pw_vector(pw, x1, y1, x0, y1, PIX_NOT(PIX_DST), 1);
X pw_vector(pw, x0, y1, x0, y0, PIX_NOT(PIX_DST), 1);
X
X return;
X}
X
Xvoid
Xset_axis_bounds(canvas, x_min, y_min, x_max, y_max)
X Canvas canvas;
X int x_min, y_min, x_max, y_max;
X{
X /*
X * Enforce a set of bounds, given in pixels, on the graph in
X * canvas.
X */
X Subframe *subframe_ptr;
X float x_min_new, x_max_new, y_min_new, y_max_new;
X
X char *gcvt(), buf[18];
X void repaint_canvas();
X Panel_item item;
X
X /* Find all the appropriate pointers */
X subframe_ptr = (Subframe *) window_get(canvas, WIN_CLIENT_DATA, 0);
X
X /* Convert the values from pixel to data coordinates */
X if (subframe_ptr->x_log) {
X x_min_new = (x_min - subframe_ptr->x_axis_min) *
X (log10(subframe_ptr->x_max) - log10(subframe_ptr->x_min)) /
X (subframe_ptr->x_axis_max - subframe_ptr->x_axis_min) +
X log10(subframe_ptr->x_min);
X x_max_new = (x_max - subframe_ptr->x_axis_min) *
X (log10(subframe_ptr->x_max) - log10(subframe_ptr->x_min)) /
X (subframe_ptr->x_axis_max - subframe_ptr->x_axis_min) +
X log10(subframe_ptr->x_min);
X x_min_new = pow(10., x_min_new);
X x_max_new = pow(10., x_max_new);
X } else {
X x_min_new = (x_min - subframe_ptr->x_axis_min) *
X (subframe_ptr->x_max - subframe_ptr->x_min) /
X (subframe_ptr->x_axis_max - subframe_ptr->x_axis_min) +
X subframe_ptr->x_min;
X x_max_new = (x_max - subframe_ptr->x_axis_min) *
X (subframe_ptr->x_max - subframe_ptr->x_min) /
X (subframe_ptr->x_axis_max - subframe_ptr->x_axis_min) +
X subframe_ptr->x_min;
X }
X if (subframe_ptr->y_log) {
X y_min_new = (y_min - subframe_ptr->y_axis_min) *
X (log10(subframe_ptr->y_max) - log10(subframe_ptr->y_min)) /
X (subframe_ptr->y_axis_max - subframe_ptr->y_axis_min) +
X log10(subframe_ptr->y_min);
X y_max_new = (y_max - subframe_ptr->y_axis_min) *
X (log10(subframe_ptr->y_max) - log10(subframe_ptr->y_min)) /
X (subframe_ptr->y_axis_max - subframe_ptr->y_axis_min) +
X log10(subframe_ptr->y_min);
X y_min_new = pow(10., y_min_new);
X y_max_new = pow(10., y_max_new);
X } else {
X y_min_new = (y_min - subframe_ptr->y_axis_min) *
X (subframe_ptr->y_max - subframe_ptr->y_min) /
X (subframe_ptr->y_axis_max - subframe_ptr->y_axis_min) +
X subframe_ptr->y_min;
X y_max_new = (y_max - subframe_ptr->y_axis_min) *
X (subframe_ptr->y_max - subframe_ptr->y_min) /
X (subframe_ptr->y_axis_max - subframe_ptr->y_axis_min) +
X subframe_ptr->y_min;
X }
X
X /* Update the props toggles to prevent overwriting */
X if (subframe_ptr->props) {
X panel_set_value(subframe_ptr->props_x_min, gcvt(x_min_new, 8, buf));
X panel_set_value(subframe_ptr->props_x_max, gcvt(x_max_new, 8, buf));
X panel_set_value(subframe_ptr->props_y_min, gcvt(y_min_new, 8, buf));
X panel_set_value(subframe_ptr->props_y_max, gcvt(y_max_new, 8, buf));
X item = (Panel_item) window_get(subframe_ptr->props, PANEL_FIRST_ITEM);
X item = (Panel_item) panel_get(item, PANEL_NEXT_ITEM);
X panel_set(item, PANEL_TOGGLE_VALUE, 0, FALSE,
X PANEL_TOGGLE_VALUE, 1, FALSE, 0);
X item = (Panel_item) panel_get(item, PANEL_NEXT_ITEM);
X panel_set(item, PANEL_TOGGLE_VALUE, 0, FALSE,
X PANEL_TOGGLE_VALUE, 1, FALSE, 0);
X }
X /* Set the values in the structures */
X subframe_ptr->x_min_auto = FALSE;
X subframe_ptr->x_max_auto = FALSE;
X subframe_ptr->y_min_auto = FALSE;
X subframe_ptr->y_max_auto = FALSE;
X subframe_ptr->x_min = x_min_new;
X subframe_ptr->x_max = x_max_new;
X subframe_ptr->y_min = y_min_new;
X subframe_ptr->y_max = y_max_new;
X
X /* Finally, rescale the graph */
X repaint_canvas(canvas);
X
X return;
X
X/* Trackertool, Version 1.0, November 1988
X *
X *
X * Copyright (c) 1988 Roy Richter, GM Corp. Anyone can use this
X * software in any manner they choose, including copying, modification
X * and redistribution, provided they make no charge for it, the source
X * code is included in the distribution, and these conditions remain
X * unchanged.
X
X *
X * This program is distributed as is, with all faults (if any), and
X * without any warranty. No author or distributor accepts responsibility
X * to anyone for the consequences of using it, or for whether it serves
X * any particular purpose at all, or any other reason.
X *
X */
X}
________This_Is_The_END________
if test `wc -l < zoom_event.c` -ne 184; then
echo -n 'shar: zoom_event.c was damaged during transit'
echo ' (should have been 184 bytes)'
fi
fi ; : end of overwriting check
exit 0
--
Roy Richter UUCP: {sharkey,edsews,cfctech}!rphroy!rrichter
Physics Dept, GM Research CSNet: rrichter at gmr.com
Internet: rrichter%rphroy.uucp at mailgw.cc.umich.edu
More information about the Comp.sources.sun
mailing list