summaryrefslogtreecommitdiff
path: root/sysutils
diff options
context:
space:
mode:
authorxtraeme <xtraeme@pkgsrc.org>2004-12-28 00:01:07 +0000
committerxtraeme <xtraeme@pkgsrc.org>2004-12-28 00:01:07 +0000
commit4b1aad95d65db0a194f36f87bbe1522c65a450d0 (patch)
treef6f6c697813f4c6359735bc6575ddfd2ddad36a2 /sysutils
parent41325c223198021b330627a8840e8d9e36306819 (diff)
downloadpkgsrc-4b1aad95d65db0a194f36f87bbe1522c65a450d0.tar.gz
Initial import of xenvstart-20041127 from pkgsrc-wip, packaged/coded by
Rui-Xiang Guo <rxg@NetBSD.org>. xenvstat displays sensor readings from any device which supports the envsys(4) API in X11-based GUI.
Diffstat (limited to 'sysutils')
-rw-r--r--sysutils/xenvstat/DESCR2
-rw-r--r--sysutils/xenvstat/Makefile32
-rw-r--r--sysutils/xenvstat/PLIST3
-rw-r--r--sysutils/xenvstat/files/Xenvstat35
-rw-r--r--sysutils/xenvstat/files/xenvstat.c839
5 files changed, 911 insertions, 0 deletions
diff --git a/sysutils/xenvstat/DESCR b/sysutils/xenvstat/DESCR
new file mode 100644
index 00000000000..fee7d6e39a7
--- /dev/null
+++ b/sysutils/xenvstat/DESCR
@@ -0,0 +1,2 @@
+xenvstat displays sensor readings from any device which supports the
+envsys(4) API in X11-based GUI.
diff --git a/sysutils/xenvstat/Makefile b/sysutils/xenvstat/Makefile
new file mode 100644
index 00000000000..8c99b1221e0
--- /dev/null
+++ b/sysutils/xenvstat/Makefile
@@ -0,0 +1,32 @@
+# $NetBSD: Makefile,v 1.1.1.1 2004/12/28 00:01:07 xtraeme Exp $
+
+DISTNAME= xenvstat-20041127
+CATEGORIES= sysutils
+MASTER_SITES= # empty
+DISTFILES= # empty
+
+MAINTAINER= rxg@NetBSD.org
+HOMEPAGE= http://www.NetBSD.org/
+COMMENT= X11-based display environmental sensor readings
+
+ONLY_FOR_PLATFORM= NetBSD-*-*
+
+NO_CONFIGURE= yes
+NO_CHECKSUM= yes
+USE_X11= yes
+USE_BUILDLINK3= yes
+
+LIBS= -lXmu -lXext -lXt -lX11 -lm
+
+do-extract:
+ @${CP} -Rp ${FILESDIR} ${WRKSRC}
+
+do-build:
+ ${CC} ${CFLAGS} ${LDFLAGS} -o ${WRKSRC}/xenvstat \
+ ${WRKSRC}/xenvstat.c ${LIBS}
+
+do-install:
+ ${INSTALL_PROGRAM} ${WRKSRC}/xenvstat ${PREFIX}/bin/xenvstat
+ ${INSTALL_DATA} ${WRKSRC}/Xenvstat ${PREFIX}/lib/X11/app-defaults
+
+.include "../../mk/bsd.pkg.mk"
diff --git a/sysutils/xenvstat/PLIST b/sysutils/xenvstat/PLIST
new file mode 100644
index 00000000000..1bd0d02f388
--- /dev/null
+++ b/sysutils/xenvstat/PLIST
@@ -0,0 +1,3 @@
+@comment $NetBSD: PLIST,v 1.1.1.1 2004/12/28 00:01:07 xtraeme Exp $
+bin/xenvstat
+lib/X11/app-defaults/Xenvstat
diff --git a/sysutils/xenvstat/files/Xenvstat b/sysutils/xenvstat/files/Xenvstat
new file mode 100644
index 00000000000..b7113625295
--- /dev/null
+++ b/sysutils/xenvstat/files/Xenvstat
@@ -0,0 +1,35 @@
+!
+! Xenvstat resource file
+!
+Xenvstat*translations: #override \
+ <Configure>: repaint_proc()\n\
+ <Expose>: repaint_proc()\n\
+ <BtnUp>: repaint_proc()\n\
+ <Key>Q: quit_proc()
+! Add the followings to users default resources if one wishes
+Xenvstat*geometry: 100x140
+Xenvstat*font: -adobe-helvetica-bold-r-*-*-10-*-*-*-*-*-*-*
+Xenvstat*count: 4
+Xenvstat*sec: 2
+Xenvstat*wsec: 180
+Xenvstat*tmin: 20.0
+Xenvstat*tmax: 60.0
+Xenvstat*vmin: 1.80
+Xenvstat*vmax: 2.20
+Xenvstat*tick: 3
+Xenvstat*cltcpu: red
+Xenvstat*cltmb: blue
+Xenvstat*cltcs: cyan
+Xenvstat*clfan1: gray
+Xenvstat*clfan2: pink
+Xenvstat*clvc: green
+Xenvstat*cmtcpu: CPU
+Xenvstat*cmtmb: MB
+Xenvstat*cmtcs: chip
+Xenvstat*cmfan1: fan1
+Xenvstat*cmfan2: fan2
+Xenvstat*cmvc: Vc
+Xenvstat*fahrn: False
+Xenvstat*label:
+Xenvstat*labelfont: -adobe-helvetica-bold-r-*-*-12-*-*-*-*-*-*-*
+Xenvstat*labelcolor: black
diff --git a/sysutils/xenvstat/files/xenvstat.c b/sysutils/xenvstat/files/xenvstat.c
new file mode 100644
index 00000000000..b37c9d36b55
--- /dev/null
+++ b/sysutils/xenvstat/files/xenvstat.c
@@ -0,0 +1,839 @@
+/*
+ * This code is derived from xmbmon.c written by Yoshifumi R. Shimizu.
+ *
+ * Copyright (c) 2004 Rui-Xiang Guo
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <err.h>
+
+#include <sys/envsys.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+
+#include <X11/Intrinsic.h>
+#include <X11/StringDefs.h>
+
+/* Fahrenheit flag used in get_values() */
+int fahrn_flag = 0;
+
+/* Label for showing or not showing a label */
+char *label;
+
+#define RES_NAME "xenvstat"
+
+#define DEFAULT_GEOMETRY "141x126"
+#define DEFAULT_FONT "-adobe-helvetica-bold-r-*-*-10-*-*-*-*-*-*-*"
+
+#define DEFAULT_LBFONT "-adobe-helvetica-bold-r-*-*-12-*-*-*-*-*-*-*"
+#define DEFAULT_LBCOLOR "black"
+
+#define DEFAULT_COUNT "4"
+#define DEFAULT_SEC "2"
+#define DEFAULT_WSEC "180"
+#define DEFAULT_TMIN "20.0"
+#define DEFAULT_TMAX "60.0"
+#define DEFAULT_TMINF "50.0" /* for Fahrenheit */
+#define DEFAULT_TMAXF "130.0" /* for Fahrenheit */
+#define DEFAULT_VMIN "1.80"
+#define DEFAULT_VMAX "2.20"
+#define DEFAULT_TICK "3"
+
+#define DEFAULT_CLTCPU "red"
+#define DEFAULT_CLTMB "blue"
+#define DEFAULT_CLTCS "cyan"
+#define DEFAULT_CLFAN1 "gray"
+#define DEFAULT_CLFAN2 "pink"
+#define DEFAULT_CLVC "green"
+
+#define DEFAULT_CMTCPU "CPU"
+#define DEFAULT_CMTMB "MB"
+#define DEFAULT_CMTCS "chip"
+#define DEFAULT_CMFAN1 "fan1"
+#define DEFAULT_CMFAN2 "fan2"
+#define DEFAULT_CMVC "Vc "
+
+#define DEFAULT_FAHRN "False"
+
+/* global variables */
+
+/* temp1(CPU), temp2(MotherBoard), temp3(ChipSet), fan1, fan2, Vcore0 */
+#define NUM_DATA 6
+
+int nd = NUM_DATA;
+
+char *font;
+
+int width, height;
+
+int count, sec, wsec;
+int counter = 0;
+int npoints = 0;
+int range;
+
+unsigned long ms;
+
+float *fmean;
+
+float tmin, tmax, vmin, vmax;
+int tick;
+float sscl, htck;
+
+float cur_val[NUM_DATA] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+char *l_color[NUM_DATA];
+unsigned long cpix[NUM_DATA], d_cpix[NUM_DATA];
+
+#define C_LBL 10
+
+char ctmin[C_LBL], ctmax[C_LBL];
+char cvmin[C_LBL], cvmax[C_LBL];
+
+char *c_rdv[NUM_DATA], *c_rdg[NUM_DATA];
+char *c_rdp[NUM_DATA] = {"%4.1f", "%4.1f", "%4.1f", "%4.0f", "%4.0f", "%4.2f"};
+
+char *lb_font, *lb_color;
+int h_lb = 0;
+
+float scale[NUM_DATA];
+float orign[NUM_DATA];
+int x_rdg[NUM_DATA], x_rdv[NUM_DATA], y_rdg, y_rdv;
+int cg_width[NUM_DATA], cv_width[NUM_DATA];
+int h_cm, x_cm, y_cm;
+unsigned long cpixlb, d_cpixlb;
+
+typedef struct ring_data { /* def. of ring-buffer */
+ float val;
+ struct ring_data *next;
+} ring_d;
+
+ring_d *rdp[NUM_DATA];
+ring_d *rdpw[NUM_DATA];
+
+int fd, ns;
+envsys_tre_data_t *etds;
+
+/* variables for X11 */
+
+Widget wgt;
+Display *disp;
+Window win;
+GC gct, gclb, gcl[NUM_DATA];
+XPoint *points;
+XFontStruct *fontstr;
+XFontStruct *lb_fontstr;
+
+/* functions */
+
+void usage(void);
+void get_res(void);
+void init_dt(void);
+void getWH(int *width, int *height);
+void repaint_proc(void);
+void quit_proc(void);
+void draw_values(void);
+int ColorPix(Display *, char *, unsigned long *);
+void alarm_handler(void);
+int num_sensors(void);
+int fill_sensors(void);
+void get_values(void);
+void calc_position(void);
+void calc_scale(void);
+
+/*---------- definitions of static data for X Toolkits ----------*/
+
+ static String fallback_resources[] = {
+ "*translations: #override \
+ <Configure>: repaint_proc()\\n\
+ <Expose>: repaint_proc()\\n\
+ <BtnUp>: repaint_proc()\\n\
+ <Key>Q: quit_proc()",
+ "*geometry: " DEFAULT_GEOMETRY,
+ "*font: " DEFAULT_FONT,
+ "*count: " DEFAULT_COUNT,
+ "*sec: " DEFAULT_SEC,
+ "*wsec: " DEFAULT_WSEC,
+ "*tmin: " DEFAULT_TMIN,
+ "*tmax: " DEFAULT_TMAX,
+ "*vmin: " DEFAULT_VMIN,
+ "*vmax: " DEFAULT_VMAX,
+ "*tick: " DEFAULT_TICK,
+ "*cltcpu: " DEFAULT_CLTCPU,
+ "*cltmb: " DEFAULT_CLTMB,
+ "*cltcs: " DEFAULT_CLTCS,
+ "*clfan1: " DEFAULT_CLFAN1,
+ "*clfan2: " DEFAULT_CLFAN2,
+ "*clvc: " DEFAULT_CLVC,
+ "*cmtcpu: " DEFAULT_CMTCPU,
+ "*cmtmb: " DEFAULT_CMTMB,
+ "*cmtcs: " DEFAULT_CMTCS,
+ "*cmfan1: " DEFAULT_CMFAN1,
+ "*cmfan2: " DEFAULT_CMFAN2,
+ "*cmvc: " DEFAULT_CMVC,
+ "*fahrn: " DEFAULT_FAHRN,
+ "*label: " ,
+ "*labelfont: " DEFAULT_LBFONT,
+ "*labelcolor: " DEFAULT_LBCOLOR,
+ NULL,
+ };
+
+ static XtActionsRec actions[] = {
+ {"repaint_proc", (XtActionProc) repaint_proc},
+ {"quit_proc", (XtActionProc) quit_proc},
+ };
+
+ static struct _app_res {
+ char *font;
+ int count;
+ int sec;
+ int wsec;
+ float tmin;
+ float tmax;
+ float vmin;
+ float vmax;
+ int tick;
+ char *cltcpu;
+ char *cltmb;
+ char *cltcs;
+ char *clfan1;
+ char *clfan2;
+ char *clvc;
+ char *cmtcpu;
+ char *cmtmb;
+ char *cmtcs;
+ char *cmfan1;
+ char *cmfan2;
+ char *cmvc;
+ Boolean fahrn;
+ char *label;
+ char *labelfont;
+ char *labelcolor;
+ } app_resources;
+
+ static XtResource resources[] = {
+ {"font", "Font", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, font),
+ XtRString, (XtPointer) NULL},
+ {"count", "Count", XtRInt, sizeof(int),
+ XtOffset(struct _app_res*, count),
+ XtRImmediate, (XtPointer) NULL},
+ {"sec", "Sec", XtRInt, sizeof(int),
+ XtOffset(struct _app_res*, sec),
+ XtRImmediate, (XtPointer) NULL},
+ {"wsec", "wSec", XtRInt, sizeof(int),
+ XtOffset(struct _app_res*, wsec),
+ XtRImmediate, (XtPointer) NULL},
+ {"tmin", "Tmin", XtRFloat, sizeof(float),
+ XtOffset(struct _app_res*, tmin),
+ XtRImmediate, (XtPointer) NULL},
+ {"tmax", "Tmax", XtRFloat, sizeof(float),
+ XtOffset(struct _app_res*, tmax),
+ XtRImmediate, (XtPointer) NULL},
+ {"vmin", "Vmin", XtRFloat, sizeof(float),
+ XtOffset(struct _app_res*, vmin),
+ XtRImmediate, (XtPointer) NULL},
+ {"vmax", "Vmax", XtRFloat, sizeof(float),
+ XtOffset(struct _app_res*, vmax),
+ XtRImmediate, (XtPointer) NULL},
+ {"tick", "Tick", XtRInt, sizeof(int),
+ XtOffset(struct _app_res*, tick),
+ XtRImmediate, (XtPointer) NULL},
+ {"cltcpu", "CLTcpu", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cltcpu),
+ XtRString, (XtPointer) NULL},
+ {"cltmb", "CLTmb", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cltmb),
+ XtRString, (XtPointer) NULL},
+ {"cltcs", "CLTcs", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cltcs),
+ XtRString, (XtPointer) NULL},
+ {"clfan1", "CLFan1", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, clfan1),
+ XtRString, (XtPointer) NULL},
+ {"clfan2", "CLFan2", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, clfan2),
+ XtRString, (XtPointer) NULL},
+ {"clvc", "CLVc", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, clvc),
+ XtRString, (XtPointer) NULL},
+ {"cmtcpu", "CMTcpu", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cmtcpu),
+ XtRString, (XtPointer) NULL},
+ {"cmtmb", "CMTmb", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cmtmb),
+ XtRString, (XtPointer) NULL},
+ {"cmtcs", "CMTcs", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cmtcs),
+ XtRString, (XtPointer) NULL},
+ {"cmfan1", "CMFan1", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cmfan1),
+ XtRString, (XtPointer) NULL},
+ {"cmfan2", "CMFan2", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cmfan2),
+ XtRString, (XtPointer) NULL},
+ {"cmvc", "CMVc", XtRString, sizeof(String),
+ XtOffset(struct _app_res*, cmvc),
+ XtRString, (XtPointer) NULL},
+ {"fahrn","Fahrn",XtRBoolean,sizeof(Boolean),
+ XtOffset(struct _app_res*, fahrn),
+ XtRImmediate, (XtPointer) NULL},
+ {"label","Label",XtRString,sizeof(String),
+ XtOffset(struct _app_res*, label),
+ XtRString,(XtPointer) NULL},
+ {"labelfont","LabelFont",XtRString,sizeof(String),
+ XtOffset(struct _app_res*, labelfont),
+ XtRString,(XtPointer) NULL},
+ {"labelcolor","LabelColor",XtRString,sizeof(String),
+ XtOffset(struct _app_res*, labelcolor),
+ XtRString,(XtPointer) NULL},
+ };
+
+ static XrmOptionDescRec options[] = {
+ {"-font", ".font", XrmoptionSepArg, NULL},
+ {"-count", ".count", XrmoptionSepArg, NULL},
+ {"-sec", ".sec", XrmoptionSepArg, NULL},
+ {"-wsec", ".wsec", XrmoptionSepArg, NULL},
+ {"-tmin", ".tmin", XrmoptionSepArg, NULL},
+ {"-tmax", ".tmax", XrmoptionSepArg, NULL},
+ {"-vmin", ".vmin", XrmoptionSepArg, NULL},
+ {"-vmax", ".vmax", XrmoptionSepArg, NULL},
+ {"-tick", ".tick", XrmoptionSepArg, NULL},
+ {"-cltcpu", ".cltcpu", XrmoptionSepArg, NULL},
+ {"-cltmb", ".cltmb", XrmoptionSepArg, NULL},
+ {"-cltcs", ".cltcs", XrmoptionSepArg, NULL},
+ {"-clfan1", ".clfan1", XrmoptionSepArg, NULL},
+ {"-clfan2", ".clfan2", XrmoptionSepArg, NULL},
+ {"-clvc", ".clvc", XrmoptionSepArg, NULL},
+ {"-cmtcpu", ".cmtcpu", XrmoptionSepArg, NULL},
+ {"-cmtmb", ".cmtmb", XrmoptionSepArg, NULL},
+ {"-cmtcs", ".cmtcs", XrmoptionSepArg, NULL},
+ {"-cmfan1", ".cmfan1", XrmoptionSepArg, NULL},
+ {"-cmfan2", ".cmfan2", XrmoptionSepArg, NULL},
+ {"-cmvc", ".cmvc", XrmoptionSepArg, NULL},
+ {"-fahrn",".fahrn",XrmoptionSepArg,NULL},
+ {"-label",".label",XrmoptionSepArg,NULL},
+ {"-labelfont",".labelfont",XrmoptionSepArg,NULL},
+ {"-labelcolor",".labelcolor",XrmoptionSepArg,NULL},
+ };
+
+/*---------- end of static data for X Toolkits ----------*/
+
+void usage(void)
+{
+ fprintf(stderr,
+""RES_NAME" options:\n"
+" -g ("DEFAULT_GEOMETRY") <geometry(Toolkit option)>\n"
+" -count ("DEFAULT_COUNT") <counts in an interval>\n"
+" -sec ("DEFAULT_SEC") <seconds of an interval>\n"
+" -wsec ("DEFAULT_WSEC") <total seconds shown>\n"
+" -tmin ("DEFAULT_TMIN") <min. temperature>\n"
+" -tmax ("DEFAULT_TMAX") <max. temperature>\n"
+" -vmin ("DEFAULT_VMIN") <min. voltage>\n"
+" -vmax ("DEFAULT_VMAX") <max. voltage>\n"
+" -tick ("DEFAULT_TICK") <ticks in ordinate>\n"
+" -cltcpu ("DEFAULT_CLTCPU") <color of Temp1>\n"
+" -cltmb ("DEFAULT_CLTMB") <color of Temp2>\n"
+" -cltcs ("DEFAULT_CLTCS") <color of Temp3>\n"
+" -clfan1 ("DEFAULT_CLFAN1") <color of Fan1>\n"
+" -clfan2 ("DEFAULT_CLFAN2") <color of Fan2>\n"
+" -clvc ("DEFAULT_CLVC") <color of Vcore>\n"
+" -cmtcpu ("DEFAULT_CMTCPU") <comment of Temp1>\n"
+" -cmtmb ("DEFAULT_CMTMB") <comment of Temp2>\n"
+" -cmtcs ("DEFAULT_CMTCS") <comment of Temp3>\n"
+" -cmfan1 ("DEFAULT_CMFAN1") <comment of Fan1>\n"
+" -cmfan2 ("DEFAULT_CMFAN2") <comment of Fan2>\n"
+" -cmvc ("DEFAULT_CMVC") <comment of Vcore>\n"
+" -fahrn ("DEFAULT_FAHRN") <temp. in Fahrenheit (True|False)>\n"
+" -label ( ) <for showing label and -labelfont, -labelcolor>\n");
+ exit(1);
+}
+
+/* Xt Application Context, global */
+XtAppContext app_con;
+
+int main(int argc, char *argv[])
+{
+ int i;
+ const char *dev = "/dev/sysmon";
+
+ for (i = 1; i < argc; i++)
+ if (0 == strcmp("-h", argv[i]) || 0 == strcmp("-help", argv[i]))
+ usage();
+
+ if ((fd = open(dev, O_RDONLY)) == -1)
+ err(1, "unable to open %s", dev);
+
+ if ((ns = num_sensors()) <= 0)
+ errx(1, "cannot determine number of sensors");
+
+ etds = (envsys_tre_data_t *)malloc(ns * sizeof(envsys_tre_data_t));
+ if (etds == NULL)
+ errx(1, "cannot allocate memory");
+
+ wgt = XtVaAppInitialize(&app_con, RES_NAME, options, XtNumber(options),
+ &argc, argv, fallback_resources, NULL);
+ XtVaGetApplicationResources(wgt, (caddr_t) &app_resources,
+ resources, XtNumber(resources), NULL);
+ XtAppAddActions(app_con, actions, XtNumber(actions));
+ XtRealizeWidget(wgt);
+
+ get_res();
+ init_dt();
+
+ XtAppAddTimeOut(app_con, ms, (XtTimerCallbackProc) alarm_handler, NULL);
+ XtAppMainLoop(app_con);
+
+ return (0);
+}
+
+void get_res()
+{
+ font = app_resources.font;
+ if (font == NULL)
+ font = DEFAULT_FONT;
+ count = app_resources.count;
+ if (count <= 0)
+ count = atoi(DEFAULT_COUNT);
+ sec = app_resources.sec;
+ if (sec <= 0)
+ sec = atoi(DEFAULT_SEC);
+ wsec = app_resources.wsec;
+ if (wsec <= 0)
+ wsec = atoi(DEFAULT_WSEC);
+ tmin = app_resources.tmin;
+ if (tmin <= 0.0)
+ tmin = (float) atof(DEFAULT_TMIN);
+ tmax = app_resources.tmax;
+ if (tmax <= 0.0)
+ tmax = (float) atof(DEFAULT_TMAX);
+ vmin = app_resources.vmin;
+ if (vmin <= 0.0)
+ vmin = (float) atof(DEFAULT_VMIN);
+ vmax = app_resources.vmax;
+ if (vmax <= 0.0)
+ vmax = (float) atof(DEFAULT_VMAX);
+ tick = app_resources.tick;
+ if (tick <= 0)
+ tick = atoi(DEFAULT_TICK);
+ l_color[0] = app_resources.cltcpu;
+ if (l_color[0] == NULL)
+ l_color[0] = DEFAULT_CLTCPU;
+ l_color[1] = app_resources.cltmb;
+ if (l_color[1] == NULL)
+ l_color[1] = DEFAULT_CLTMB;
+ l_color[2] = app_resources.cltcs;
+ if (l_color[2] == NULL)
+ l_color[2] = DEFAULT_CLTCS;
+ l_color[3] = app_resources.clfan1;
+ if (l_color[3] == NULL)
+ l_color[3] = DEFAULT_CLFAN1;
+ l_color[4] = app_resources.clfan2;
+ if (l_color[4] == NULL)
+ l_color[4] = DEFAULT_CLFAN2;
+ l_color[5] = app_resources.clvc;
+ if (l_color[5] == NULL)
+ l_color[5] = DEFAULT_CLVC;
+ c_rdg[0] = app_resources.cmtcpu;
+ if (c_rdg[0] == NULL)
+ c_rdg[0] = DEFAULT_CMTCPU;
+ c_rdg[1] = app_resources.cmtmb;
+ if (c_rdg[1] == NULL)
+ c_rdg[1] = DEFAULT_CMTMB;
+ c_rdg[2] = app_resources.cmtcs;
+ if (c_rdg[2] == NULL)
+ c_rdg[2] = DEFAULT_CMTCS;
+ c_rdg[3] = app_resources.cmfan1;
+ if (c_rdg[3] == NULL)
+ c_rdg[3] = DEFAULT_CMFAN1;
+ c_rdg[4] = app_resources.cmfan2;
+ if (c_rdg[4] == NULL)
+ c_rdg[4] = DEFAULT_CMFAN2;
+ c_rdg[5] = app_resources.cmvc;
+ if (c_rdg[5] == NULL)
+ c_rdg[5] = DEFAULT_CMVC;
+ if (app_resources.fahrn) {
+ fahrn_flag = 1;
+ if (tmin == (float) atof(DEFAULT_TMIN) &&
+ tmax == (float) atof(DEFAULT_TMAX)) {
+ tmin = (float) atof(DEFAULT_TMINF);
+ tmax = (float) atof(DEFAULT_TMAXF);
+ }
+ }
+ label = app_resources.label;
+ lb_font = app_resources.labelfont;
+ lb_color = app_resources.labelcolor;
+ if (lb_color == NULL)
+ lb_color = DEFAULT_LBCOLOR;
+}
+
+void quit_proc(void)
+{
+ exit(1);
+}
+
+void repaint_proc(void)
+{
+ int wwd, hht;
+ int i, n;
+ ring_d *p;
+
+ getWH(&wwd, &hht);
+ if (wwd != width) {
+ width = wwd;
+ x_cm = width - XTextWidth(fontstr, cvmin, strlen(cvmin)) - 1;
+ sscl = (float) width / (float) range;
+ calc_position();
+ }
+
+ if (hht != height) {
+ height = hht;
+ calc_scale();
+ }
+
+ XClearWindow(disp, win);
+
+ if(*label != NULL)
+ XDrawString(disp, win, gclb, 2, h_lb - 2, label, strlen(label));
+
+ for (i = 0; i < nd; i++) {
+ XDrawString(disp, win, gcl[i], x_rdg[i], y_rdg,
+ c_rdg[i], strlen(c_rdg[i]));
+ XDrawString(disp, win, gcl[i], x_rdv[i], y_rdv,
+ c_rdv[i], strlen(c_rdv[i]));
+ }
+
+ XDrawString(disp, win, gct, 0, height, ctmin, strlen(ctmin));
+ XDrawString(disp, win, gct, 0, y_cm, ctmax, strlen(ctmax));
+ XDrawString(disp, win, gct, x_cm, height, cvmin, strlen(cvmin));
+ XDrawString(disp, win, gct, x_cm, y_cm, cvmax, strlen(cvmax));
+
+ for (i = 1; i <= tick + 1; i++) {
+ n = height - (int) ((float) i * htck + 0.5);
+ XDrawLine(disp, win, gct, 0, n, width, n);
+ }
+
+ for (i = nd - 1; i >= 0; i--) {
+ for (n = 0, p = rdp[i]; n < npoints; n++) {
+ (points + n)->x = (short) ((float) n * sscl + 0.5);
+ (points + n)->y = height -
+ (short) ((p->val - orign[i]) * scale[i] + 0.5);
+ p = p->next;
+ }
+
+ if (scale[i])
+ XDrawLines(disp, win, gcl[i], points, npoints,
+ CoordModeOrigin);
+ }
+
+ XFlush(disp);
+}
+
+void getWH(int *width, int *height)
+{
+ Dimension wd, ht;
+
+ XtVaGetValues(wgt, XtNwidth, &wd, XtNheight, &ht, NULL);
+ *width = (int) wd;
+ *height = (int) ht;
+}
+
+int ColorPix(Display *display, char *color, unsigned long *cpix)
+{
+ Colormap cmap;
+ XColor c0, c1;
+
+ if (color == NULL)
+ return (1);
+
+ cmap = DefaultColormap(display, 0);
+ if (XAllocNamedColor(disp, cmap, color, &c1, &c0)) {
+ *cpix = c1.pixel;
+ return (0);
+ } else
+ return (1);
+}
+
+void init_dt(void)
+{
+ ring_d *p;
+ int n, i;
+
+ if (wsec < 10 * sec)
+ errx(1, "wsec(%d) is too small w.r.t sec(%d)!", wsec, sec);
+
+ if (tmax < tmin)
+ errx(1, "tmin(%f) > tmax(%f), not allowed!", tmin, tmax);
+
+ if (vmax < vmin)
+ errx(1, "vmin(%f) > vmax(%f), not allowed!", vmin, vmax);
+
+ if (fill_sensors() == -1)
+ errx(1, "cannot enumerate sensors");
+
+ get_values();
+ disp = XtDisplay(wgt);
+ win = XtWindow(wgt);
+
+ if ((fontstr = XLoadQueryFont(disp, font)) == NULL)
+ errx(1, "Can't find font: %s\n", font);
+
+ ColorPix(disp, DEFAULT_CLTCPU, &(d_cpix[0]));
+ ColorPix(disp, DEFAULT_CLTMB, &(d_cpix[1]));
+ ColorPix(disp, DEFAULT_CLTCS, &(d_cpix[2]));
+ ColorPix(disp, DEFAULT_CLFAN1, &(d_cpix[3]));
+ ColorPix(disp, DEFAULT_CLFAN2, &(d_cpix[4]));
+ ColorPix(disp, DEFAULT_CLVC, &(d_cpix[5]));
+ gct = XCreateGC(disp, win, 0, 0);
+ XSetFont(disp, gct, fontstr->fid);
+
+ for (i = 0; i < nd; i++) {
+ if (ColorPix(disp, l_color[i], &(cpix[i])))
+ cpix[i] = d_cpix[i];
+
+ gcl[i] = XCreateGC(disp, win, 0, 0);
+ XSetLineAttributes(disp, gcl[i], 2, LineSolid, CapRound,
+ JoinRound);
+ XSetForeground(disp, gcl[i], cpix[i]);
+ XSetFont(disp, gcl[i], fontstr->fid);
+ c_rdv[i] = (char *) malloc(C_LBL);
+ sprintf(c_rdv[i], c_rdp[i], cur_val[i]);
+ cg_width[i] = XTextWidth(fontstr, c_rdg[i], strlen(c_rdg[i]));
+ cv_width[i] = XTextWidth(fontstr, c_rdv[i], strlen(c_rdv[i]));
+ }
+
+ if(*label != NULL) {
+ if ((lb_fontstr = XLoadQueryFont(disp, lb_font)) == NULL)
+ errx(1, "Can't find font for label: %s\n", font);
+
+ ColorPix(disp, DEFAULT_LBCOLOR, &d_cpixlb);
+ if (ColorPix(disp, lb_color, &cpixlb))
+ cpixlb = d_cpixlb;
+
+ gclb = XCreateGC(disp, win, 0, 0);
+ XSetFont(disp, gclb, lb_fontstr->fid);
+ XSetForeground(disp, gclb, cpixlb);
+ }
+
+ sprintf(ctmin, "%2.0f", tmin);
+ sprintf(ctmax, "%2.0f", tmax);
+ sprintf(cvmin, "%3.1f", vmin);
+ sprintf(cvmax, "%3.1f", vmax);
+
+ range = wsec / sec;
+ points = (XPoint *) malloc(sizeof(short) * 2 * (range + 1));
+
+ for (i = 0; i < nd; i++) {
+ rdp[i] = p = (ring_d *) malloc(sizeof(ring_d));
+ rdpw[i] = p;
+ for (n = 1; n < (range + 1); n++) {
+ p->next = (ring_d *) malloc(sizeof(ring_d));
+ p = p->next;
+ }
+
+ p->next = rdp[i];
+ }
+
+ fmean = (float *) malloc(sizeof(float) * nd * count);
+
+ getWH(&width, &height);
+ sscl = (float) width / (float) range;
+ orign[0] = tmin;
+ orign[1] = tmin;
+ orign[2] = tmin;
+ orign[5] = vmin;
+ x_rdg[0] = 0;
+ x_rdv[0] = 0;
+
+ calc_position();
+
+ y_rdg = fontstr->max_bounds.ascent - 1;
+ y_rdv = 2 * y_rdg;
+
+ if(*label != NULL) {
+ h_lb = lb_fontstr->max_bounds.ascent + 1;
+ y_rdg += h_lb;
+ y_rdv += h_lb;
+ }
+
+ h_cm = 2 * fontstr->max_bounds.ascent;
+ y_cm = h_cm + y_rdg;
+ x_cm = width - XTextWidth(fontstr, cvmin, strlen(cvmin));
+ calc_scale();
+
+ ms = 1000 * sec / count;
+}
+
+void alarm_handler(void)
+{
+ float d, *p;
+ int i, n;
+
+ get_values();
+ if (fill_sensors() == -1)
+ errx(1, "cannot enumerate sensors");
+
+ if (cur_val[0] >= tmax)
+ XBell(XtDisplay(wgt), 0);
+
+ draw_values();
+
+ p = fmean + counter;
+ for (i = 0; i < nd; i++)
+ *(p + i * count) = cur_val[i];
+
+ counter++;
+ if (counter == count) {
+ if (npoints <= range)
+ npoints++;
+ else
+ for (i = 0; i < nd; i++)
+ rdp[i] = rdp[i]->next;
+
+ counter = 0;
+ p = fmean;
+ for (i = 0; i < nd; i++) {
+ for (n = 0, d = 0.0; n < count; n++, p++)
+ d += *p;
+
+ rdpw[i]->val = d / (float) count;
+ rdpw[i] = rdpw[i]->next;
+ }
+
+ repaint_proc();
+ }
+
+ XtAppAddTimeOut(app_con, ms, (XtTimerCallbackProc) alarm_handler, NULL);
+}
+
+void draw_values(void)
+{
+ int i;
+
+ XClearArea(disp, win, 0, y_rdg , 0, y_rdg - h_lb, False);
+ for (i = 0; i < nd; i++) {
+ sprintf(c_rdv[i], c_rdp[i], cur_val[i]);
+ XDrawString(disp, win, gcl[i], x_rdv[i], y_rdv,
+ c_rdv[i], strlen(c_rdv[i]));
+ }
+
+ XFlush(disp);
+}
+
+void calc_position(void)
+{
+ int i, cg_r, cv_r;
+
+ cg_r = width - (cg_width[0] + cg_width[nd - 1]) / 2;
+ cv_r = width - (cv_width[0] + cv_width[nd - 1]) / 2;
+ for (i = 1; i <= nd - 1; i++) {
+ x_rdg[i] =
+ cg_width[0] / 2 + cg_r * i / (nd - 1) - cg_width[i] / 2;
+ x_rdv[i] =
+ cv_width[0] / 2 + cv_r * i / (nd - 1) - cv_width[i] / 2;
+ }
+}
+
+void calc_scale(void)
+{
+ float tscl, vscl;
+
+ tscl = (float) (height - h_lb - h_cm) / (tmax - tmin);
+ vscl = (float) (height - h_lb - h_cm) / (vmax - vmin);
+ htck = (float) (height - h_lb - h_cm) / (float) (tick + 1);
+ scale[0] = tscl;
+ scale[1] = tscl;
+ scale[2] = tscl;
+ scale[3] = 0;
+ scale[4] = 0;
+ scale[5] = vscl;
+}
+
+int num_sensors(void)
+{
+ int num = 0, valid = 1;
+ envsys_tre_data_t etd;
+ etd.sensor = 0;
+
+ while (valid) {
+ if (ioctl(fd, ENVSYS_GTREDATA, &etd) == -1)
+ errx(1, "cannot enumerate sensors");
+
+ valid = etd.validflags & ENVSYS_FVALID;
+ if (valid)
+ ++num;
+
+ ++etd.sensor;
+ }
+
+ return (num);
+}
+
+int fill_sensors(void)
+{
+ int i;
+
+ for (i = 0; i < ns; ++i) {
+ etds[i].sensor = i;
+ if (ioctl(fd, ENVSYS_GTREDATA, &etds[i]) == -1)
+ return (-1);
+ }
+
+ return (0);
+}
+
+void get_values(void)
+{
+ int i, j = 0, k = 0, l = 0;
+
+ for (i = 0; i < ns; ++i) {
+ if ((etds[i].validflags & ENVSYS_FCURVALID) == 0)
+ continue;
+
+ switch (etds[i].units) {
+ case ENVSYS_STEMP:
+ cur_val[j] = (etds[i].cur.data_us / 1000000.0) - 273.15;
+ if (fahrn_flag)
+ cur_val[j] = (9.0 / 5.0) * cur_val[j] + 32.0;
+
+ ++j;
+ break;
+ case ENVSYS_SFANRPM:
+ if (k < 2)
+ cur_val[k + 3] = etds[i].cur.data_us;
+
+ ++k;
+ break;
+ default:
+ if (l < 1)
+ cur_val[5] = etds[i].cur.data_s / 1000000.0;
+
+ ++l;
+ break;
+ }
+ }
+}