tkstripchart.c

rtpmon-1.0a7.tar.gz for UNIX like

/*
 * tkStripchart.c --
 *
 *      This module implements "Stripchart" widgets for the Tk
 *      toolkit.
 *
 * Copyright 1992 Regents of the University of Victoria, Wellington, NZ.
 * This code is derived from the tkScale widget.
 * Copyright 1990 Regents of the University of California.
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies.  The University of California
 * makes no representations about the suitability of this
 * software for any purpose.  It is provided "as is" without
 * express or implied warranty.
 *
 *  BUGS:
 *   sometimes the callback procedure doesn't work (????)
 *    (it can often be made to work by setting a (different) value and
 *     restarting the callback procedure.)
 *
 *  CHANGES:
 *   would be nicer having tick interval instead of numticks.
 *
 */

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "tk.h"

#if TK_MINOR_VERSION<1
#define Tk_Cursor Cursor
#endif

#define BLACK		"Black"
#define WHITE		"White"
#define GRAY		"#b0b0b0"
#define BISQUE1		"#ffe4c4"
#define MAROON		"#b03060"

#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif

/*
 *  Default stripchart configuration values
 */

#define DEF_STRIPCHART_BG_COLOR            BISQUE1
#define DEF_STRIPCHART_STRIP_COLOR         BLACK
#define DEF_STRIPCHART_TEXT_COLOR          BLACK
#define DEF_STRIPCHART_TICK_COLOR          GRAY
#define DEF_STRIPCHART_CURSOR              0

#define ALT_STRIPCHART_BG_COLOR            MAROON
#define ALT_STRIPCHART_STRIP_COLOR         WHITE
#define ALT_STRIPCHART_TEXT_COLOR          WHITE
#define ALT_STRIPCHART_TICK_COLOR          GRAY

/*
 * for monochrome displays
 */
#define DEF_STRIPCHART_BG_MONO             WHITE
#define DEF_STRIPCHART_STRIP_MONO          BLACK
#define DEF_STRIPCHART_TEXT_MONO           BLACK
#define DEF_STRIPCHART_TICK_MONO           BLACK

#define ALT_STRIPCHART_BG_MONO             BLACK
#define ALT_STRIPCHART_STRIP_MONO          WHITE
#define ALT_STRIPCHART_TEXT_MONO           WHITE
#define ALT_STRIPCHART_TICK_MONO           WHITE

#define DEF_STRIPCHART_NUMSTRIPS           "40"
#define DEF_STRIPCHART_NUMTICKS            "11"
#define DEF_STRIPCHART_BORDER_WIDTH        "3"
#define DEF_STRIPCHART_FONT                "*-Helvetica-Bold-R-Normal-*-120-*"
#define DEF_STRIPCHART_MINVALUE            "0"
#define DEF_STRIPCHART_MAXVALUE            "1000"
#define DEF_STRIPCHART_CALLBACK_INTERVAL   "500"
#define DEF_STRIPCHART_TITLE               0
#define DEF_STRIPCHART_HEIGHT              "80"
#define DEF_STRIPCHART_RELIEF              "flat"
#define DEF_STRIPCHART_TICK_INTERVAL       "50"
#define DEF_STRIPCHART_WIDTH               "1"
#define DEF_STRIPCHART_STRIPBORDERWIDTH    "0"
#define DEF_STRIPCHART_STRIPRELIEF         "flat"
#define DEF_STRIPCHART_SHOWTICKS           "true"
#define DEF_STRIPCHART_AUTOSCALE           "0"
#define DEF_STRIPCHART_HTICKS              "0"
#define DEF_USERBITS                       "0"
#define DEF_USERDATA                       0
#define DEF_GUARANTEE_DRAW                 "false"

#define  MAX_STRIPS              100
#define  MAX_TICKS               40
#define  PADDING                 2
#define  hasatitle(d)            (((d)->title != NULL) && \
                                  ((d)->title[0] != '\0'))
#ifndef abs
#define  abs(x)                  ( (x) < 0 ? -(x) : (x) )
#endif

/*
 * A data structure of the following type is kept for each
 * Stripchart that currently exists for this process:
 */

typedef struct strip_struct Stripchart;

struct strip_struct {
	Tk_Window tkwin;	/* Window that embodies the Stripchart.  NULL
				 * means that the window has been destroyed
				 * but the data structures haven't yet been
				 * cleaned up.*/
	Tcl_Interp *interp;	/* Interpreter associated with widget.  Used
				 * to delete widget command.  */
	Tk_Uid screenName;	/* If this window isn't a toplevel window
				 * then this is NULL;  otherwise it gives the
				 * name of the screen on which window is
				 * displayed. */
	Tk_3DBorder border;	/* Structure used to draw 3-D border and
				 * background. */
	int borderWidth;	/* Width of 3-D border (if any). */
	int relief;		/* 3-d effect: TK_RELIEF_RAISED etc. */
	Tk_Cursor cursor;	/* Current cursor for window, or None. */
	Tk_3DBorder stripBorder;/* Structure used to draw the strips */
	int stripBorderWidth;
	int stripRelief;
	int strip_width;	/* width of a strip */
	int max_height;		/* maximum height of a strip */
	int num_strips;		/* the number of strips */
	int stripstodisplay;	/* how many of the num_strips should be
				 * displayed. */
	int num_ticks;		/* the number of ticks to display */
	double *value;		/* the data to be displayed in strip form. */
	double min_value;
	double max_value;
	double data_min;
	double data_max;
	int scrollrequired;
	int guarantee_draw;
	int grow_up;
	XFontStruct *fontPtr;	/* Information about text font, or NULL. */
	XColor *textColorPtr;	/* Color for drawing text. */
	GC textGC;		/* GC for drawing text. */
	XColor *tickColorPtr;	/* Color for drawing ticks. */
	GC tickGC;		/* GC for drawing ticks. */
	int showticks;
	int autoscale;
	int hticks;
	int lasthtick;

	/*
	 * call back stuff
	 */
	Tk_TimerToken timer;	/* tk timer used by callback */
	char *command;		/* Command used for callback. Malloc'ed. */
	char *rescale_command;	/* Command invoked on autorescale. Malloc'ed. */
	int continue_callback;	/* boolean flag used to terminate the
				 * callback */
	unsigned long interval;	/* interval (mS) between callbacks */
	double (*callback_func)(Tcl_Interp* interp, Stripchart* stripPtr);
			        /* Function to be invoked on callback. */
	char *title;		/* Label to display above of stripchart; NULL
				 * means don't display a title.  Malloc'ed. */
	int displaybits;	/* Various flags;  see below for definitions. */
	int userbits;
	char *userdata;
	/*
	 * Alternative colour scheme
	 */
	Tk_3DBorder altborder;	/* Structure used to draw border  */
	Tk_3DBorder altstripBorder;/* structure used to draw strip  */
	XColor *a_textColor;	/* alternative text color         */
	XColor *a_tickColor;	/* alternative tick color         */

};

/*
 * displaybits for Stripcharts:
 *
 * REDRAW_PENDING:              Non-zero means a DoWhenIdle handler
 *                              has already been queued to redraw
 *                              this window.
 * CLEAR_NEEDED:                Need to clear the window when redrawing.
 * DISPLAY_TITLE:               Draw the title, if there is one.
 * DISPLAY_STRIPS:              Draw the strips.
 * DISPLAY_BORDER:              Draw the border.
 * DISPLAY_TICKS:               Draw the ticks.
 * DISPLAY_ALL:                 Display everything.
 */

#define   REDRAW_PENDING		1
#define   CLEAR_NEEDED	        	2
#define   DISPLAY_TITLE                 4
#define   DISPLAY_STRIPS                8
#define   DISPLAY_BORDER               16
#define   DISPLAY_TICKS                32
#define   DISPLAY_ALL                  (DISPLAY_TITLE | DISPLAY_STRIPS | \
					DISPLAY_BORDER | DISPLAY_TICKS)

static Tk_ConfigSpec configSpecs[] =
{
	{TK_CONFIG_BORDER, "-altbackground", "altbackground", "Background",
	 ALT_STRIPCHART_BG_COLOR, Tk_Offset(Stripchart, altborder),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_BORDER, "-altbackground", "altbackground", "Background",
	 ALT_STRIPCHART_BG_MONO, Tk_Offset(Stripchart, altborder),
	 TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_BORDER, "-altstripcolor", "altstripcolor",
	 "Foreground", ALT_STRIPCHART_STRIP_COLOR,
	 Tk_Offset(Stripchart, altstripBorder), TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_BORDER, "-altstripcolor", "altstripcolor",
	 "Foreground", ALT_STRIPCHART_STRIP_MONO,
	 Tk_Offset(Stripchart, altstripBorder), TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_COLOR, "-alttextcolor", "textcolor", "Foreground",
	 ALT_STRIPCHART_TEXT_COLOR, Tk_Offset(Stripchart, a_textColor),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_COLOR, "-alttextcolor", "textcolor", "Foreground",
	 ALT_STRIPCHART_TEXT_MONO, Tk_Offset(Stripchart, a_textColor),
	 TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_COLOR, "-alttickcolor", "tickcolor", "Foreground",
	 ALT_STRIPCHART_TICK_COLOR, Tk_Offset(Stripchart, a_tickColor),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_COLOR, "-alttickcolor", "tickcolor", "Foreground",
	 ALT_STRIPCHART_TICK_MONO, Tk_Offset(Stripchart, a_tickColor),
	 TK_CONFIG_MONO_ONLY},

	{TK_CONFIG_BORDER, "-background", "background", "Background",
	 DEF_STRIPCHART_BG_COLOR, Tk_Offset(Stripchart, border),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_BORDER, "-background", "background", "Background",
	 DEF_STRIPCHART_BG_MONO, Tk_Offset(Stripchart, border),
	 TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_SYNONYM, "-bd", "borderWidth", 0, 0, 0, 0},
	{TK_CONFIG_SYNONYM, "-bg", "background", 0, 0, 0, 0},
	{TK_CONFIG_INT, "-borderwidth", "borderWidth", "BorderWidth",
	 DEF_STRIPCHART_BORDER_WIDTH, Tk_Offset(Stripchart, borderWidth), 0},
	{TK_CONFIG_STRING, "-command", "command", "Command",
	 0, Tk_Offset(Stripchart, command), 0},
	{TK_CONFIG_STRING, "-rescale_command", "rescale_command", "RescaleCommand",
	 0, Tk_Offset(Stripchart, rescale_command), 0},
	{TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
	 DEF_STRIPCHART_CURSOR, Tk_Offset(Stripchart, cursor),
	 TK_CONFIG_NULL_OK},

	{TK_CONFIG_STRING, "-data", "data", "Data",
	 DEF_USERDATA, Tk_Offset(Stripchart, userdata), 0},
	{TK_CONFIG_SYNONYM, "-fg", "stripcolor", 0,
	 0, 0, 0},
	{TK_CONFIG_FONT, "-font", "font", "Font",
	 DEF_STRIPCHART_FONT, Tk_Offset(Stripchart, fontPtr),
	 0},
	{TK_CONFIG_BOOLEAN, "-guaranteedrawing", "guaranteedrawing",
	 "Guaranteedrawing", DEF_GUARANTEE_DRAW,
	 Tk_Offset(Stripchart, guarantee_draw), 0},
	{TK_CONFIG_INT, "-height", "height", "Height", DEF_STRIPCHART_HEIGHT,
	 Tk_Offset(Stripchart, max_height), 0},
	{TK_CONFIG_INT, "-interval", "interval", "Interval",
      DEF_STRIPCHART_CALLBACK_INTERVAL, Tk_Offset(Stripchart, interval), 0},
	{TK_CONFIG_DOUBLE, "-max", "max", "Max",
	 DEF_STRIPCHART_MAXVALUE, Tk_Offset(Stripchart, max_value), 0},
	{TK_CONFIG_DOUBLE, "-min", "min", "Min",
	 DEF_STRIPCHART_MINVALUE, Tk_Offset(Stripchart, min_value), 0},
	{TK_CONFIG_INT, "-numstrips", "numstrips", "Numstrips",
	 DEF_STRIPCHART_NUMSTRIPS, Tk_Offset(Stripchart, num_strips), 0},
	{TK_CONFIG_INT, "-numticks", "numticks", "Numticks",
	 DEF_STRIPCHART_NUMTICKS, Tk_Offset(Stripchart, num_ticks), 0},
	{TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
	 DEF_STRIPCHART_RELIEF, Tk_Offset(Stripchart, relief), 0},
	{TK_CONFIG_BOOLEAN, "-showticks", "showticks", "Showticks",
	 DEF_STRIPCHART_SHOWTICKS, Tk_Offset(Stripchart, showticks), 0},
	{TK_CONFIG_INT, "-autoscale", "autoscale", "Autoscale",
	 DEF_STRIPCHART_AUTOSCALE, Tk_Offset(Stripchart, autoscale), 0},
	{TK_CONFIG_INT, "-hticks", "hticks", "Hticks",
	 DEF_STRIPCHART_HTICKS, Tk_Offset(Stripchart, hticks), 0},
	{TK_CONFIG_INT, "-stripborderwidth", "stripborderwidth",
	 "Stripborderwidth", DEF_STRIPCHART_STRIPBORDERWIDTH,
	 Tk_Offset(Stripchart, stripBorderWidth), 0},
	{TK_CONFIG_BORDER, "-stripcolor", "stripcolor", "Stripcolor",
	 DEF_STRIPCHART_STRIP_COLOR, Tk_Offset(Stripchart, stripBorder),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_BORDER, "-stripcolor", "stripcolor", "Stripcolor",
	 DEF_STRIPCHART_STRIP_MONO, Tk_Offset(Stripchart, stripBorder),
	 TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_RELIEF, "-striprelief", "striprelief", "Striprelief",
	 DEF_STRIPCHART_STRIPRELIEF, Tk_Offset(Stripchart, stripRelief), 0},
	{TK_CONFIG_INT, "-stripwidth", "stripwidth", "Stripwidth",
	 DEF_STRIPCHART_WIDTH, Tk_Offset(Stripchart, strip_width), 0},
	{TK_CONFIG_COLOR, "-textcolor", "textcolor", "Textcolor",
	 DEF_STRIPCHART_TEXT_COLOR, Tk_Offset(Stripchart, textColorPtr),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_COLOR, "-textcolor", "textcolor", "Textcolor",
	 DEF_STRIPCHART_TEXT_MONO, Tk_Offset(Stripchart, textColorPtr),
	 TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_COLOR, "-tickcolor", "tickcolor", "Tickcolor",
	 DEF_STRIPCHART_TICK_COLOR, Tk_Offset(Stripchart, tickColorPtr),
	 TK_CONFIG_COLOR_ONLY},
	{TK_CONFIG_COLOR, "-tickcolor", "tickcolor", "Tickcolor",
	 DEF_STRIPCHART_TICK_MONO, Tk_Offset(Stripchart, tickColorPtr),
	 TK_CONFIG_MONO_ONLY},
	{TK_CONFIG_STRING, "-title", "title", "Title",
	 DEF_STRIPCHART_TITLE, Tk_Offset(Stripchart, title), 0},
	{TK_CONFIG_BOOLEAN, "-up", "up", "Up", "true",
	 Tk_Offset(Stripchart, grow_up), 0},
	{TK_CONFIG_INT, "-userbits", "userbits", "Userbits",
	 DEF_USERBITS, Tk_Offset(Stripchart, userbits), 0},
	{TK_CONFIG_INT, "-width", "width", "Width", DEF_STRIPCHART_WIDTH,
	 Tk_Offset(Stripchart, strip_width), 0},
	{TK_CONFIG_END, 0, 0, 0,
	 0, 0, 0}
};

/*
 * Forward declarations for procedures defined later in this file:
 */
static void Callback(Stripchart* StripchartPtr);
static void ComputeStripchartGeometry(Stripchart* StripchartPtr);
static int ConfigureStripchart(Tcl_Interp* interp, Stripchart* StripchartPtr,
				int argc, char** argv, int flags);
static void DestroyStripchart(ClientData clientData);
static void DisplayStripchart(ClientData clientData);
static void DrawStripi(Stripchart* StripchartPtr, int i);
static void EventuallyRedrawStripchart(Stripchart* StripchartPtr,
				       int displaybits);
static void ReplaceColours(Stripchart* StripchartPtr, int argc, char** argv);
static void ScrollStrips(Stripchart* StripchartPtr);
static void StripchartEventProc(ClientData clientData, XEvent* eventPtr);
static int StripchartWidgetCmd(ClientData clientData, Tcl_Interp* interp,
				int argc, char** argv);
static void SetStripchartValue(Stripchart* StripchartPtr, double value);
static void SwapColours(Stripchart* StripchartPtr);

/*
 *--------------------------------------------------------------
 *
 * Tk_StripchartCmd --
 *
 *      This procedure is invoked to process the "Stripchart" and
 *      "toplevel" Tcl commands.  See the user documentation for
 *      details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */
int
Tk_StripchartCmd(ClientData clientData, Tcl_Interp *interp, int argc,
		 char **argv)
 {
	Tk_Window tkwin = (Tk_Window) clientData;
	Tk_Window new;
	register Stripchart *StripchartPtr;

	if (argc < 2) {
		Tcl_AppendResult(interp, "wrong # args: should be \"",
			    argv[0], " pathName ?options?\"", 0);
		return TCL_ERROR;
	}
	/*
	 * Create the window.
	 */
	new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], 0);
	if (new == NULL)
		return TCL_ERROR;

	Tk_SetClass(new, "Stripchart");
	StripchartPtr = (Stripchart*)calloc(1, sizeof(Stripchart));
	StripchartPtr->tkwin = new;
	StripchartPtr->interp = interp;

	Tk_CreateEventHandler(StripchartPtr->tkwin,
			      ExposureMask | StructureNotifyMask,
			      StripchartEventProc, (ClientData) StripchartPtr);
	Tcl_CreateCommand(interp, Tk_PathName(StripchartPtr->tkwin),