tkstripchart.c

rtpmon-1.0a7.tar.gz for UNIX like

			  StripchartWidgetCmd, (ClientData)StripchartPtr,
			  0);

	if (ConfigureStripchart(interp, StripchartPtr, argc - 2, argv + 2, 0)
	    != TCL_OK) {
		Tk_DestroyWindow(StripchartPtr->tkwin);
		return TCL_ERROR;
	}
	interp->result = Tk_PathName(StripchartPtr->tkwin);
	return TCL_OK;
}

/*
 * StripchartWidgetCmd --
 *
 *      This procedure is invoked to process the Tcl command
 *      that corresponds to a Stripchart widget.  See the user
 *      documentation for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 */
static int
StripchartWidgetCmd(ClientData clientData, Tcl_Interp *interp,
		    int argc, char **argv)
{
	register Stripchart *StripchartPtr = (Stripchart*)clientData;
	int result = TCL_OK;
	int length;
	char c;

	if (argc < 2) {
		Tcl_AppendResult(interp, "wrong # args: should be \"",
			  argv[0], " option ?arg arg ...?\"", 0);
		return TCL_ERROR;
	}
	Tk_Preserve((ClientData) StripchartPtr);
	c = argv[1][0];
	length = strlen(argv[1]);
	if (strncmp(argv[1], "configure", length) == 0) {
		if (argc == 2) {
			result = Tk_ConfigureInfo(interp, StripchartPtr->tkwin,
						  configSpecs,
						  (char*)StripchartPtr,
						  (char*)NULL, 0);
		} else if (argc == 3) {
			result = Tk_ConfigureInfo(interp, StripchartPtr->tkwin,
						  configSpecs,
						  (char*)StripchartPtr,
						  argv[2], 0);
		} else {
			result = ConfigureStripchart(interp, StripchartPtr,
						     argc - 2, argv + 2,
						     TK_CONFIG_ARGV_ONLY);
		}
	} else if (strncmp(argv[1], "get", length) == 0) {
		if (argc != 2) {
			Tcl_AppendResult(interp, "wrong # args: should be \"",
					 argv[0], " get\"", 0);
			result = TCL_ERROR;
		} else
			sprintf(interp->result, "%g",
			  StripchartPtr->value[
				  StripchartPtr->stripstodisplay - 1]);
	} else if (strncmp(argv[1], "set", length) == 0) {
		double value;

		if (argc != 3) {
			Tcl_AppendResult(interp, "wrong # args: should be \"",
				     argv[0], " set value\"", 0);
			result = TCL_ERROR;
		} else if (Tcl_GetDouble(interp, argv[2], &value) != TCL_OK)
			result = TCL_ERROR;
		 else
			SetStripchartValue(StripchartPtr, value);
	} else if (strncmp(argv[1], "start", length) == 0) {
		if (!StripchartPtr->continue_callback) {
			StripchartPtr->continue_callback = TRUE;
			Callback(StripchartPtr);
		}
	} else if (strncmp(argv[1], "stop", length) == 0) {
		StripchartPtr->continue_callback = FALSE;
	} else if (strncmp(argv[1], "reset", length) == 0) {
		StripchartPtr->stripstodisplay = 0;
		StripchartPtr->scrollrequired = FALSE;
		EventuallyRedrawStripchart(StripchartPtr,
					   DISPLAY_ALL | CLEAR_NEEDED);
	} else if (strncmp(argv[1], "swapcolours", length) == 0) {
		SwapColours(StripchartPtr);
	} else if (strncmp(argv[1], "replacecolours", length) == 0) {
		ReplaceColours(StripchartPtr, argc - 2, argv + 2);
	} else {
		Tcl_AppendResult(interp, "bad option \"", argv[1],
		   "\":  must be configure, get, set, reset, start or stop",
				 0);
		result = TCL_ERROR;
	}
	Tk_Release((ClientData) StripchartPtr);
	return result;
}

/*
 *  Callback --
 *      Execute a Tcl command repeatedly until told to stop.  Involked
 *      with the start command and stopped with the stop command.
 *
 *  Results:
 *      None.
 *
 *  Side Effects:
 *      Timer queue is changed with the addition of a command to be
 *      executed periodically.
 */
static void 
Callback(Stripchart *StripchartPtr)
{
	int result;

	StripchartPtr->timer = 0;
	if (StripchartPtr->callback_func != NULL)
		SetStripchartValue(StripchartPtr,
				   (*(StripchartPtr->callback_func))
					(StripchartPtr->interp, StripchartPtr));
	if (StripchartPtr->command != NULL &&
	    StripchartPtr->command[0] != '\0') {
		result = Tcl_Eval(StripchartPtr->interp,
				  StripchartPtr->command);
		if (result == TCL_OK)
			if (StripchartPtr->continue_callback)
				StripchartPtr->timer =
				   Tk_CreateTimerHandler(
						StripchartPtr->interval,
						(void *)Callback,
						(ClientData)StripchartPtr);
	}
}

/*
 * DestroyStripchart --
 *
 *      This procedure is invoked by Tk_EventuallyFree or Tk_Release
 *      to clean up the internal structure of a Stripchart at a safe time
 *      (when no-one is using it anymore).
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Everything associated with the Stripchart is freed up.
 */
static void
DestroyStripchart(ClientData clientData)
{
	Stripchart* StripchartPtr = (Stripchart*)clientData;

	if (StripchartPtr->timer)
		Tk_DeleteTimerHandler(StripchartPtr->timer);

	if (StripchartPtr->border != NULL)
		Tk_Free3DBorder(StripchartPtr->border);

	if (StripchartPtr->altborder != NULL)
		Tk_Free3DBorder(StripchartPtr->altborder);

	if (StripchartPtr->stripBorder != NULL)
		Tk_Free3DBorder(StripchartPtr->stripBorder);

	if (StripchartPtr->altstripBorder != NULL)
		Tk_Free3DBorder(StripchartPtr->altstripBorder);

	if (StripchartPtr->title != NULL)
		ckfree(StripchartPtr->title);

	if (StripchartPtr->command != NULL)
		ckfree(StripchartPtr->command);

	if (StripchartPtr->rescale_command != NULL)
		ckfree(StripchartPtr->rescale_command);

	if (StripchartPtr->value != NULL)
		free(StripchartPtr->value);

	if (StripchartPtr->fontPtr != NULL)
		Tk_FreeFontStruct(StripchartPtr->fontPtr);

	if (StripchartPtr->textColorPtr != NULL)
		Tk_FreeColor(StripchartPtr->textColorPtr);

	if (StripchartPtr->textGC != None && StripchartPtr->tkwin)
		Tk_FreeGC(Tk_Display(StripchartPtr->tkwin),
			  StripchartPtr->textGC);

	if (StripchartPtr->tickColorPtr != NULL)
		Tk_FreeColor(StripchartPtr->tickColorPtr);

	if (StripchartPtr->tickGC != None && StripchartPtr->tkwin)
		Tk_FreeGC(Tk_Display(StripchartPtr->tkwin),
			  StripchartPtr->tickGC);

	if (StripchartPtr->a_textColor != NULL)
		Tk_FreeColor(StripchartPtr->a_textColor);

	if (StripchartPtr->a_tickColor != NULL)
		Tk_FreeColor(StripchartPtr->a_tickColor);

	if (StripchartPtr->cursor != None && StripchartPtr->tkwin) {
		Tk_FreeCursor(Tk_Display(StripchartPtr->tkwin),
			      StripchartPtr->cursor);
	}
	ckfree((char *)StripchartPtr);
}

/*
 * ConfigureStripchart --
 *
 *      This procedure is called to process an argv/argc list, plus
 *      the Tk option database, in order to configure (or
 *      reconfigure) a Stripchart widget.
 *
 * Results:
 *      The return value is a standard Tcl result.  If TCL_ERROR is
 *      returned, then interp->result contains an error message.
 *
 * Side effects:
 *      Configuration information, such as text string, colors, font,
 *      etc. get set for StripchartPtr;  old resources get freed, if there
 *      were any.
 */
static int
ConfigureStripchart(Tcl_Interp *interp, Stripchart *StripchartPtr,
		    int argc, char** argv, int flags)
{
	XGCValues gcValues;
	GC newGC;
	int result;

	result = Tk_ConfigureWidget(interp, StripchartPtr->tkwin, configSpecs,
				    argc, argv, (char *)StripchartPtr, flags);
	if (result != TCL_OK)
		return result;

	Tk_SetBackgroundFromBorder(StripchartPtr->tkwin, StripchartPtr->border);

	gcValues.font = StripchartPtr->fontPtr->fid;
	gcValues.foreground = StripchartPtr->textColorPtr->pixel;
	newGC = Tk_GetGC(StripchartPtr->tkwin, GCForeground|GCFont, &gcValues);
	if (StripchartPtr->textGC != None && StripchartPtr->tkwin) {
		Tk_FreeGC(Tk_Display(StripchartPtr->tkwin),
			  StripchartPtr->textGC);
	}
	StripchartPtr->textGC = newGC;

	gcValues.foreground = StripchartPtr->tickColorPtr->pixel;
	newGC = Tk_GetGC(StripchartPtr->tkwin, GCForeground, &gcValues);
	if (StripchartPtr->tickGC != None && StripchartPtr->tkwin) {
		Tk_FreeGC(Tk_Display(StripchartPtr->tkwin),
			  StripchartPtr->tickGC);
	}
	StripchartPtr->tickGC = newGC;

	if (StripchartPtr->value == 0)
		StripchartPtr->value = (double*)calloc(
						StripchartPtr->num_strips,
						sizeof(*StripchartPtr->value));
	else
		StripchartPtr->value = (double*)realloc(
						StripchartPtr->value,
						StripchartPtr->num_strips *
						sizeof(*StripchartPtr->value));
	if (StripchartPtr->num_ticks > MAX_TICKS)
		StripchartPtr->num_ticks = MAX_TICKS;

	if (StripchartPtr->min_value > StripchartPtr->max_value) {
		double temp = StripchartPtr->min_value;
		StripchartPtr->min_value = StripchartPtr->max_value;
		StripchartPtr->max_value = temp;
	}
	/*
	 * Recompute display-related information, and let the geometry
	 * manager know how much space is needed now.
	 */
	ComputeStripchartGeometry(StripchartPtr);
	EventuallyRedrawStripchart(StripchartPtr, DISPLAY_ALL | CLEAR_NEEDED);
	return TCL_OK;
}

/*
 * ComputeStripchartGeometry --
 *
 *      This procedure is called to compute various geometrical
 *      information for a stripchart, such as where various things get
 *      displayed.  It's called when the window is reconfigured.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 */
static void
ComputeStripchartGeometry(Stripchart* StripchartPtr)
 {
	int tt = hasatitle(StripchartPtr);
	int bd = StripchartPtr->borderWidth;
	int lineHeight = StripchartPtr->fontPtr->ascent +
	StripchartPtr->fontPtr->descent;

	Tk_GeometryRequest(StripchartPtr->tkwin,
			   2 * (bd + PADDING) + StripchartPtr->num_strips *
			   StripchartPtr->strip_width,
			   2 * (bd + PADDING) + tt * (lineHeight + PADDING) +
			   StripchartPtr->max_height);
	Tk_SetInternalBorder(StripchartPtr->tkwin, StripchartPtr->borderWidth);
}

/*
 * DisplayStripchart --
 *
 *      This procedure is invoked to display a Stripchart widget.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Commands are output to X to display the Stripchart in its
 *      current mode.
 */
static void
DisplayStripchart(ClientData clientData)
 {
	Stripchart *StripchartPtr = (Stripchart *) clientData;
	Tk_Window tkwin = StripchartPtr->tkwin;
	int bd = StripchartPtr->borderWidth;
	int i, tt = hasatitle(StripchartPtr);

	/*
	 * Variable declarations used in the title drawing routines
	 */
	XFontStruct *fp = StripchartPtr->fontPtr;
	XCharStruct bbox;
	int x, dummy;
	int lineHeight = StripchartPtr->fontPtr->ascent +
	StripchartPtr->fontPtr->descent;

	StripchartPtr->displaybits &= ~REDRAW_PENDING;
	if ((StripchartPtr->tkwin == NULL) || !Tk_IsMapped(tkwin))
		return;

	/*
	 * Clear the window if necessary
	 */
	if (StripchartPtr->displaybits & CLEAR_NEEDED)
		XClearWindow(Tk_Display(tkwin), Tk_WindowId(tkwin));

	/*
	 * Display the title, centered in the window if there is enough
	 * space. Otherwise left justified and clipped on the right.
	 */
	if (tt && StripchartPtr->displaybits & DISPLAY_TITLE) {
		XTextExtents(fp, StripchartPtr->title,
			     strlen(StripchartPtr->title),
			     &dummy, &dummy, &dummy, &bbox);
		if (bbox.lbearing + bbox.rbearing < Tk_Width(tkwin) - 2 * bd)
			x = (Tk_Width(tkwin) - bbox.lbearing - bbox.rbearing)/2;
		else
			x = bd + PADDING;

		XClearArea(Tk_Display(tkwin), Tk_WindowId(tkwin), bd, bd,
		     Tk_Width(tkwin) - 2 * bd, lineHeight + PADDING, False);
		XDrawString(Tk_Display(tkwin), Tk_WindowId(tkwin),
		       StripchartPtr->textGC, x, fp->max_bounds.ascent + bd,
			StripchartPtr->title, strlen(StripchartPtr->title));
	}
	/*
	 * draw the strips
	 */
	if (StripchartPtr->displaybits & CLEAR_NEEDED) {
		StripchartPtr->displaybits &= ~CLEAR_NEEDED;
		StripchartPtr->lasthtick = 0;
		for (i = 1; i <= StripchartPtr->stripstodisplay; i++)
			DrawStripi(StripchartPtr, i);