StripChart.c File Reference

#include <stdio.h>
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Xaw3d/XawInit.h>
#include <X11/Xaw3d/StripCharP.h>
#include <X11/Xfuncs.h>

Include dependency graph for StripChart.c:

Go to the source code of this file.

Defines
#define	MS_PER_SEC   1000
#define	offset(field)   XtOffsetOf(StripChartRec, field)
#define	HEIGHT   ( (unsigned int) w->core.height)
Functions
static void	Initialize ()
static void	Destroy ()
static void	Redisplay ()
static void	MoveChart ()
static void	SetPoints ()
static Boolean	SetValues ()
static int	repaint_window ()
static void	draw_it ()
static void	CreateGC (StripChartWidget w, unsigned int which)
static void	DestroyGC (StripChartWidget w, unsigned int which)
static void	Initialize (Widget greq, Widget gnew, ArgList args, Cardinal *num_args)
static void	Destroy (Widget gw)
static void	Redisplay (Widget gw, XEvent *event, Region region)
static void	draw_it (XtPointer client_data, XtIntervalId *id)
static int	repaint_window (Widget gw, int left, int width)
static void	MoveChart (StripChartWidget w, Boolean blit)
static Boolean	SetValues (Widget current, Widget request, Widget new, ArgList args, Cardinal *num_args)
static void	SetPoints (Widget widget)
Variables
static XtResource	resources []
StripChartClassRec	stripChartClassRec
WidgetClass	stripChartWidgetClass = (WidgetClass) &stripChartClassRec

---

Define Documentation

#define HEIGHT   ( (unsigned int) w->core.height)

Definition at line 526 of file StripChart.c.

#define MS_PER_SEC   1000

Definition at line 58 of file StripChart.c.

Referenced by draw_it(), Initialize(), and SetValues().

#define offset

(

field

)

XtOffsetOf(StripChartRec, field)

Definition at line 62 of file StripChart.c.

---

Function Documentation

static void CreateGC	(	StripChartWidget	w,
		unsigned int	which
	)			[static]

Definition at line 154 of file StripChart.c.

References FOREGROUND, and HIGHLIGHT.

{
  XGCValues     myXGCV;

  if (which & FOREGROUND) {
    myXGCV.foreground = w->strip_chart.fgpixel;
    w->strip_chart.fgGC = XtGetGC((Widget) w, GCForeground, &myXGCV);
  }

  if (which & HIGHLIGHT) {
    myXGCV.foreground = w->strip_chart.hipixel;
    w->strip_chart.hiGC = XtGetGC((Widget) w, GCForeground, &myXGCV);
  }
}

static void Destroy

(

Widget

gw

)

[static]

Definition at line 212 of file StripChart.c.

References ALL_GCS, DestroyGC(), and w.

{
     StripChartWidget w = (StripChartWidget)gw;

     if (w->strip_chart.update > 0)
         XtRemoveTimeOut (w->strip_chart.interval_id);
     if (w->strip_chart.points)
         XtFree((char *) w->strip_chart.points);
     DestroyGC(w, (unsigned int) ALL_GCS);
}

Here is the call graph for this function:

static void Destroy

(

)

static void DestroyGC	(	StripChartWidget	w,
		unsigned int	which
	)			[static]

Definition at line 179 of file StripChart.c.

References FOREGROUND, and HIGHLIGHT.

{
  if (which & FOREGROUND) 
    XtReleaseGC((Widget) w, w->strip_chart.fgGC);

  if (which & HIGHLIGHT) 
    XtReleaseGC((Widget) w, w->strip_chart.hiGC);
}

static void draw_it	(	XtPointer	client_data,
		XtIntervalId *	id
	)			[static]

Definition at line 260 of file StripChart.c.

References CoordModePrevious, draw_it(), FALSE, MoveChart(), MS_PER_SEC, NULL, repaint_window(), s, ThreeDClassPart::shadowdraw, _StripChartClassRec::threeD_class, TRUE, value, w, XDrawPoints(), XtNgetValue, and y.

{
   StripChartWidget w = (StripChartWidget)client_data;
   StripChartWidgetClass swclass = (StripChartWidgetClass) XtClass ((Widget) w);
   Dimension s = w->threeD.shadow_width;
   double value;
   
   if (w->strip_chart.update > 0)
       w->strip_chart.interval_id =
       XtAppAddTimeOut(XtWidgetToApplicationContext( (Widget) w),
                       (unsigned long) w->strip_chart.update * MS_PER_SEC,
                       draw_it, client_data);

   if (w->strip_chart.interval >= (int)( w->core.width - 2 * s))
       MoveChart( (StripChartWidget) w, TRUE);

   /* Get the value, stash the point and draw corresponding line. */

   if (w->strip_chart.get_value == NULL)
       return;

   XtCallCallbacks( (Widget)w, XtNgetValue, (XtPointer)&value );

   /* 
    * Keep w->strip_chart.max_value up to date, and if this data 
    * point is off the graph, change the scale to make it fit. 
    */
   
   if (value > w->strip_chart.max_value) {
       w->strip_chart.max_value = value;
       if (XtIsRealized((Widget)w) && 
           w->strip_chart.max_value > w->strip_chart.scale) {
           XClearWindow(XtDisplay ((Widget) w), XtWindow ((Widget) w));
           w->strip_chart.interval = repaint_window((Widget)w, 0, (int) w->core.width - 2 * s);
           (*swclass->threeD_class.shadowdraw) ((Widget) w, 
                                                (XEvent *)0, (Region)0, 
                                                FALSE);
       }
   }

   w->strip_chart.valuedata[w->strip_chart.interval] = value;
   if (XtIsRealized((Widget)w)) {
       int y = (int) (( w->core.height - 2 * s)
                      - (int)(( w->core.height - 2 * s) * value) / w->strip_chart.scale);

        XFillRectangle(XtDisplay((Widget) w), XtWindow((Widget) w), w->strip_chart.fgGC,
                       w->strip_chart.interval + s, 
                       y + s, (unsigned int) 1, 
                       (w->core.height - 2 * s) - y);
       /*
        * Fill in the graph lines we just painted over.
        */

       if (w->strip_chart.points != NULL) {
           w->strip_chart.points[0].x = w->strip_chart.interval + s;
           XDrawPoints(XtDisplay(w), XtWindow(w), w->strip_chart.hiGC,
                       w->strip_chart.points, w->strip_chart.scale,
                       CoordModePrevious);
       }

       XFlush(XtDisplay(w));                /* Flush output buffers */
   }
   w->strip_chart.interval++;               /* Next point */
} /* draw_it */

Here is the call graph for this function:

static void draw_it

(

)

[static]

Referenced by draw_it(), Initialize(), and SetValues().

Here is the caller graph for this function:

static void Initialize	(	Widget	greq,
		Widget	gnew,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 191 of file StripChart.c.

References ALL_GCS, CreateGC(), draw_it(), MS_PER_SEC, NULL, SetPoints(), and w.

{
    StripChartWidget w = (StripChartWidget)gnew;

    if (w->strip_chart.update > 0)
        w->strip_chart.interval_id = 
            XtAppAddTimeOut( XtWidgetToApplicationContext(gnew),
                             (unsigned long) w->strip_chart.update * MS_PER_SEC, 
                             draw_it, (XtPointer) gnew);
    CreateGC(w, (unsigned int) ALL_GCS);

    w->strip_chart.scale = w->strip_chart.min_scale;
    w->strip_chart.interval = 0;
    w->strip_chart.max_value = 0.0;
    w->strip_chart.points = NULL;
    SetPoints((Widget)w);
}

Here is the call graph for this function:

static void Initialize

(

void

)

[static]

static void MoveChart	(	StripChartWidget	w,
		Boolean	blit
	)			[static]

Definition at line 410 of file StripChart.c.

References DEFAULT_JUMP, i, j, left, repaint_window(), s, and void().

{
    Dimension s = w->threeD.shadow_width;
    double old_max;
    int left, i, j;
    int next = w->strip_chart.interval;

    if (!XtIsRealized((Widget) w)) return;

    if (w->strip_chart.jump_val < 0) w->strip_chart.jump_val = DEFAULT_JUMP;
    if (w->strip_chart.jump_val == DEFAULT_JUMP)
        j = ( w->core.width - 2 * s) / 2; /* Half the window width. */
    else {
        j = ( w->core.width - 2 * s) - w->strip_chart.jump_val;
        if (j < 0) j = 0;
    }

    (void) memmove((char *)(w->strip_chart.valuedata), 
                   (char *)(w->strip_chart.valuedata + next - j),
                   j * sizeof(double));
    next = w->strip_chart.interval = j;
        
    /*
     * Since we just lost some data, recompute the 
     * w->strip_chart.max_value. 
     */

    old_max = w->strip_chart.max_value;
    w->strip_chart.max_value = 0.0;
    for (i = 0; i < next; i++) {
      if (w->strip_chart.valuedata[i] > w->strip_chart.max_value) 
        w->strip_chart.max_value = w->strip_chart.valuedata[i];
    }

    if (!blit) return;          /* we are done... */

    if ( ((int) old_max) != ( (int) w->strip_chart.max_value) ) {
      XClearWindow(XtDisplay(w), XtWindow(w));
      repaint_window((Widget)w, 0, w->core.width - 2 * s);
      return;
    }

    XCopyArea(XtDisplay((Widget)w), XtWindow((Widget)w), XtWindow((Widget)w),
              w->strip_chart.hiGC, 
              (int) ((w->strip_chart.jump_val == DEFAULT_JUMP) ?
                     (j + s) : (w->strip_chart.jump_val + s)), s,
              (unsigned int) j, (unsigned int) ( w->core.height - 2 * s),
              s, s);

    XClearArea(XtDisplay((Widget)w), XtWindow((Widget)w), 
               (int) j + s, s, 
               (unsigned int) ((w->strip_chart.jump_val == DEFAULT_JUMP) ?
                               j : w->strip_chart.jump_val),
               (unsigned int) ( w->core.height - 2 * s),
               FALSE);

    /* Draw graph reference lines */
    left = j;
    for (i = 1; i < w->strip_chart.scale; i++) {
        j = i * ((w->core.height - 2 * s) / w->strip_chart.scale);
        XDrawLine(XtDisplay((Widget) w), XtWindow( (Widget) w),
            w->strip_chart.hiGC, 
            left, j + s, ((int)w->core.width - s - 1), j + s);
    }
    return;
}

Here is the call graph for this function:

static void MoveChart

(

)

Referenced by draw_it().

Here is the caller graph for this function:

static void Redisplay	(	Widget	gw,
		XEvent *	event,
		Region	region
	)			[static]

Definition at line 231 of file StripChart.c.

References FALSE, s, ThreeDClassPart::shadowdraw, _StripChartClassRec::threeD_class, void(), w, width, and x.

{

    StripChartWidget w = (StripChartWidget)gw;
    StripChartWidgetClass swclass = (StripChartWidgetClass) XtClass (gw);
    Dimension x, width, s = w->threeD.shadow_width;

    (*swclass->threeD_class.shadowdraw) (gw, event, region, FALSE);

    if (event->type == GraphicsExpose) {
        x = event->xgraphicsexpose.x;
        width = event->xgraphicsexpose.width;
    } else {
        x = event->xexpose.x;
        width = event->xexpose.width;
    }
    if (x > s) x -= s; /* respect shadow width, but don't become negative */
    else x = 0;
    if (x + width > w->core.width - 2 * s) /* ditto for right boundary */
        width = w->core.width - 2 * s - x;

    (void) repaint_window (gw, x, width);
}

Here is the call graph for this function:

static void Redisplay

(

)

static int repaint_window	(	Widget	gw,
		int	left,
		int	width
	)			[static]

Definition at line 338 of file StripChart.c.

References dpy, FALSE, i, j, s, scale, SetPoints(), ThreeDClassPart::shadowdraw, _StripChartClassRec::threeD_class, w, and y.

{
    StripChartWidget w = (StripChartWidget) gw;
    Dimension s = w->threeD.shadow_width;
    StripChartWidgetClass swclass = (StripChartWidgetClass) XtClass ((Widget) w);
    int i, j;
    int next = w->strip_chart.interval;
    int scale = w->strip_chart.scale;
    int scalewidth = 0;

    /* Compute the minimum scale required to graph the data, but don't go
       lower than min_scale. */
    if (w->strip_chart.interval != 0 || scale <= (int)w->strip_chart.max_value)
      scale = ((int) (w->strip_chart.max_value)) + 1;
    if (scale < w->strip_chart.min_scale)
      scale = w->strip_chart.min_scale;

    if (scale != w->strip_chart.scale) {
      w->strip_chart.scale = scale;
      left = 0;
      width = next;                             /* check this */
      scalewidth = w->core.width - 2 * s;

      SetPoints(gw);

      if (XtIsRealized (gw)) {
        XClearWindow (XtDisplay (gw), XtWindow (gw));
        (*swclass->threeD_class.shadowdraw) (gw, (XEvent *)0, (Region)0, FALSE);
      }

    }

    if (XtIsRealized(gw)) {
        Display *dpy = XtDisplay(gw);
        Window win = XtWindow(gw);

        width += left - 1;
        if (!scalewidth) scalewidth = width;

        if (next < (++width - s)) width = next + s;

        /* Draw data point lines. */
        for (i = left; i < width; i++) {
            int y = (int) (( w->core.height - 2 * s) -
                           (int)(( w->core.height - 2 * s) * w->strip_chart.valuedata[i]) / 
                           w->strip_chart.scale);

            XFillRectangle(dpy, win, w->strip_chart.fgGC, 
                           i + s, y + s, (unsigned int) 1,
                           (unsigned int) (w->core.height - 2 * s - y ));
        }

        /* Draw graph reference lines */
        for (i = 1; i < w->strip_chart.scale; i++) {
            j = i * ((w->core.height - 2 * s) / w->strip_chart.scale);
            XDrawLine(dpy, win, w->strip_chart.hiGC, 
                left + s, j + s, scalewidth + s, j + s);
        }
    }
    return(next);
}

Here is the call graph for this function:

static int repaint_window

(

)

[static]

Referenced by draw_it(), and MoveChart().

Here is the caller graph for this function:

static void SetPoints

(

Widget

widget

)

[static]

Definition at line 529 of file StripChart.c.

References i, NULL, points, s, size, w, and x.

{
    StripChartWidget w = (StripChartWidget) widget;
    Dimension s = w->threeD.shadow_width;
    XPoint * points;
    Cardinal size;
    int i;

    if (w->strip_chart.scale <= 1) { /* no scale lines. */
        XtFree ((char *) w->strip_chart.points);
        w->strip_chart.points = NULL;
        return;
    }
    
    size = sizeof(XPoint) * (w->strip_chart.scale - 1);

    points = (XPoint *) XtRealloc( (XtPointer) w->strip_chart.points, size);
    w->strip_chart.points = points;

    /* Draw graph reference lines into clip mask */

    for (i = 1; i < w->strip_chart.scale; i++) {
        points[i - 1].x = 0;
        points[i - 1].y = ( short)(((double)w->core.height - 2.0 * (double) s) / (double) w->strip_chart.scale );
    }
    points[0].y += (short)s;
}

static void SetPoints

(

)

Referenced by Initialize(), and repaint_window().

Here is the caller graph for this function:

static Boolean SetValues	(	Widget	current,
		Widget	request,
		Widget	new,
		ArgList	args,
		Cardinal *	num_args
	)			[static]

Definition at line 480 of file StripChart.c.

References CreateGC(), DestroyGC(), draw_it(), FALSE, StripChartPart::fgpixel, FOREGROUND, HIGHLIGHT, StripChartPart::hipixel, StripChartPart::interval_id, MS_PER_SEC, NO_GCS, _StripChartRec::strip_chart, TRUE, StripChartPart::update, and w.

{
    StripChartWidget old = (StripChartWidget)current;
    StripChartWidget w = (StripChartWidget)new;
    Boolean ret_val = FALSE;
    unsigned int new_gc = NO_GCS;

    if (w->strip_chart.update != old->strip_chart.update) {
        if (old->strip_chart.update > 0)
            XtRemoveTimeOut (old->strip_chart.interval_id);
        if (w->strip_chart.update > 0)
            w->strip_chart.interval_id =
                XtAppAddTimeOut(XtWidgetToApplicationContext(new),
                                (unsigned long) w->strip_chart.update * MS_PER_SEC,
                                draw_it, (XtPointer)w);
    }

    if ( w->strip_chart.min_scale > (int) ((w->strip_chart.max_value) + 1) )
      ret_val = TRUE;
     
    if ( w->strip_chart.fgpixel != old->strip_chart.fgpixel ) {
      new_gc |= FOREGROUND;
      ret_val = True;
    }
    
    if ( w->strip_chart.hipixel != old->strip_chart.hipixel ) {
      new_gc |= HIGHLIGHT;
      ret_val = True;
    }
    
    DestroyGC(old, new_gc);
    CreateGC(w, new_gc);

    return( ret_val );
}

Here is the call graph for this function:

static Boolean SetValues

(

)

[static]

---

Variable Documentation

XtResource resources[] [static]

Initial value:

 {
    {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
        offset(core.width), XtRImmediate, (XtPointer) 120},
    {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
        offset(core.height), XtRImmediate, (XtPointer) 120},
    {XtNupdate, XtCInterval, XtRInt, sizeof(int),
        offset(strip_chart.update), XtRImmediate, (XtPointer) 10},
    {XtNminScale, XtCScale, XtRInt, sizeof(int),
        offset(strip_chart.min_scale), XtRImmediate, (XtPointer) 1},
    {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
        offset(strip_chart.fgpixel), XtRString, XtDefaultForeground},
    {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel),
        offset(strip_chart.hipixel), XtRString, XtDefaultForeground},
    {XtNgetValue, XtCCallback, XtRCallback, sizeof(XtPointer),
        offset(strip_chart.get_value), XtRImmediate, (XtPointer) NULL},
    {XtNjumpScroll, XtCJumpScroll, XtRInt, sizeof(int),
        offset(strip_chart.jump_val), XtRImmediate, (XtPointer) DEFAULT_JUMP},
}

Definition at line 64 of file StripChart.c.

StripChartClassRec stripChartClassRec

Definition at line 89 of file StripChart.c.

WidgetClass stripChartWidgetClass = (WidgetClass) &stripChartClassRec

Definition at line 136 of file StripChart.c.

---