arti/irix-657m-src
1
0
Fork 0
Code Activity
Files
main
irix-657m-src/eoe/cmd/gr_osview/rtbar.c
calmsacibis995 8fc8fa8089 Source code upload
2022-09-29 17:59:04 +03:00

1864 lines
41 KiB
C
Raw Permalink Blame History

/**************************************************************************
* *
* Copyright (C) 1989, Silicon Graphics, Inc. *
* *
* These coded instructions, statements, and computer programs contain *
* unpublished proprietary information of Silicon Graphics, Inc., and *
* are protected by Federal copyright law. They may not be disclosed *
* to third parties or copied or duplicated in any form, in whole or *
* in part, without the prior written consent of Silicon Graphics, Inc. *
* *
**************************************************************************/
/*
* 3D moving color bar module.
* J. M. Barton 03/19/88
*/
# include <gl.h>
# include <gl/device.h>
# include <stdlib.h>
# include <math.h>
# include <fmclient.h>
# include <malloc.h>
# include <memory.h>
# include <stdarg.h>
# include <string.h>
# include "grosview.h"
/*
* DEFXPERY basically defined how long a bar is
*/
# define DEFXPERY 9.5 /* aspect ratio */
# define PNTINCH 72.0 /* points per inch */
# define DEFFONT "TimesBoldItalic"
# define J_LEFT 0 /* left justify number */
# define J_RIGHT 1 /* right justify number */
# define XSHRINK ((float)0.97) /* to provide border around bar */
# define YBAROFF ((float)0.05) /* bottom of slot to bar bottom */
# define YBARSCALE ((float)0.55) /* size of bar space */
/*
* define text base above base of bar
* An entire bar is 1.0 units high - so we center the baseline of the
* text in the space remaining after the real bar portion
*/
# define YTEXTBASE ((((1.0 - (YBAROFF + YBARSCALE)) - cheight)/2) + (YBAROFF+YBARSCALE))
# define CHEIGHT 0.25 /* size of a canonical character */
# define BORDER (YBARSCALE*0.2) /* size of bar and window border */
# define YBARMID (YBAROFF+(YBARSCALE/2))
# define YBARTOP (YBAROFF+YBARSCALE)
# define YBARBOT (YBAROFF)
# define MINYSIZE 45 /* minimum pixels in Y */
# define MINXSIZE ((long)(DEFXPERY*MINYSIZE))/* minimum pixels in X */
# define NDIVS 10 /* number of ticks in bar */
# define YSIZE ((nbars + (width - 1)) / width)
# define AVGSTR " Avg "
# define TICKPER 0.2
# define GETCPOS(x,y) getcpos(x, y)
# define scrmask(r,l,b,t)
# define TALPHA "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890"
Colorindex frontcolor = BLACK;
Colorindex backcolor = DEFBACKCOLOR;
Colorindex palecolor = DEFPALECOLOR;
char *fontface;
int arbsize = 0;
int width = 1;
static colorblock_t *bars[MAXBARS];
static int nbars = 0;
static int windes;
static char doublebuffered = 0;
static char *tfont;
static fmfonthandle rtfont;
static fmfontinfo rtfontinfo;
static int inredraw = 0;
static float cheight = CHEIGHT;
static float bheight = 0.0; /* baseline height */
static fmfonthandle deffontfh; /* handle for basic dft font */
/*
* Window screen coordinates for other modules to use.
*/
static long winposx; /* origin in x */
static long winposy; /* origin in y */
static long winsizex; /* size in x */
static long winsizey; /* size in y */
static int newwin = 1;
/*
* Sliding scale to use when autosizing the bar under varying conditions.
*/
# define MAXSCALE 9
static struct {
int disval;
int decay; /* scale decay (in units) */
int advance; /* advance hysterisis (in units) */
} sscale[MAXSCALE] = {
10, 20, 5,
50, 75, 5,
100, 100, 5,
200, 70, 10,
1000, 50, 10,
5000, 50, 15,
20000, 50, 15,
100000, 50, 20,
500000, 50, 30,
};
static void cbwinsetup(int);
static void cbredrawstrip(colorblock_t *);
static void cbredraw1(colorblock_t *);
static void cbstredraw(colorblock_t *);
static void cbstquickdraw(colorblock_t *);
static void cbdrawmax(colorblock_t *);
static void cbredrawnum(colorblock_t *);
static void cbonebar(colorblock_t *);
static void cbnumdraw(colorblock_t *, int, int, float);
static void barlimit(colorblock_t *, double *);
static void barclamp(colorblock_t *, double *);
static void barmax(colorblock_t *, double *);
static void cbstalloc(colorblock_t *, int);
static int cbydist(Screencoord, Screencoord);
# define doscrmask(x) \
scrmask((x)->cb_scrmask[0], (x)->cb_scrmask[1], \
(x)->cb_scrmask[2], (x)->cb_scrmask[3]);
# define _drawlimit(cbp) \
cbnumdraw(cbp, 2, J_RIGHT, cbp->cb_tlimit)
# define _drawmax(cbp) \
cbnumdraw(cbp, 1, J_RIGHT, cbp->cb_dispmax)
# define _drawsum(cbp) \
cbnumdraw(cbp, 0, J_RIGHT, cbp->cb_lastavg1)
# define halfpix(tp) (tp->cb_ftwid/2)
void
rtbar_text_start(void) {} /* beginning of text to lock down */
void
FMPRSTR(char *s) {
if (nofont)
return;
else
fmprstr(s);
}
static char *
displaynum(float pstr, int scale)
{
static char tstr[10];
char *str = tstr;
if (pstr < 0) {
*str++ = '-';
pstr = fabs(pstr);
}
if (scale) {
if (pstr < 1024)
sprintf(str, "%.1fm", pstr);
else
sprintf(str, "%.2fg", pstr/1024.0);
}
else if (pstr < 64*1024)
sprintf(str, "%d", (int) pstr);
else if (pstr < 1024*1024)
sprintf(str, "%.1fk", pstr / 1024.0);
else if (pstr < 1024*1024*1024)
sprintf(str, "%.1fm", pstr / (1024.0*1024));
else
sprintf(str, "%.2fg", pstr / (1024.0*1024*1024));
return(str);
}
float
masksum(colorblock_t *cbp, float *data) {
int i;
float rval;
rval = 0;
for (i = 0; i < cbp->cb_nsects; i++) {
if (!(mask(i)&cbp->cb_nmask))
rval += data[i];
}
return(rval);
}
float
unmasksum(colorblock_t *cbp, float *data) {
int i;
float rval;
rval = 0;
for (i = 0; i < cbp->cb_nsects; i++) {
rval += data[i];
}
return(rval);
}
/*
* Swap the buffers.
*/
void
cbswapbuf(void)
{
if (doublebuffered) {
swapbuffers();
cbredraw();
}
}
/*
* Redraw the bars and names.
*/
void
cbredraw(void)
{
colorblock_t *tp;
inredraw = 1;
tp = nextbar(1);
while (tp != 0) {
if (tp->cb_type == T_NUM)
tp->cb_flags |= TF_REMAX;
cbredraw1(tp);
tp = nextbar(0);
}
inredraw = 0;
}
/*
* cbdrawlegend - draw the character string legend for a particular
* bar.
*/
void
cbdrawlegend(colorblock_t *tp)
{
int j;
color(backcolor);
rectf(tp->cb_cposx, tp->cb_cposy, tp->cb_cposx + tp->cb_strwid,
tp->cb_cposy + (rtfontinfo.ysize * tp->cb_ftsywid));
color(frontcolor);
cmov2(tp->cb_cposx, tp->cb_cposy + (rtfontinfo.yorig * tp->cb_ftsywid));
FMPRSTR(tp->cb_header);
for (j = 0; j < tp->cb_nsects; j++) {
color(tp->cb_colors[j]);
FMPRSTR(tp->cb_legend[j]);
}
if (tp->cb_type == T_NUM) {
if (tp->cb_flags & TF_AVERAGE) {
color(frontcolor);
FMPRSTR(AVGSTR);
}
}
cbdrawabs(tp);
}
/*
* cbdraw - draw the given color bar at the given place in the given
* colors. calls the clamping function if necessary.
*/
void
cbdraw(colorblock_t *cbp, ...)
{
va_list ap;
double nvals[MAXSECTS];
int i;
#ifdef JEFF
logcbdraw(&va_alist);
#endif
if (cbp->cb_flags & TF_ONETRIP) {
cbp->cb_flags &= ~TF_ONETRIP;
return;
}
va_start(ap, cbp);
for (i = 0; i < cbp->cb_nsects; i++) {
nvals[i] = va_arg(ap, double);
}
va_end(ap);
switch (cbp->cb_type) {
case T_SABS:
case T_ABS:
barlimit(cbp, nvals);
break;
case T_SREL:
case T_REL:
barclamp(cbp, nvals);
break;
case T_NUM:
barmax(cbp, nvals);
break;
}
cbredraw1(cbp);
}
/*
* cbdrawabs - draw the limit value for a bar.
*/
void
cbdrawabs(colorblock_t *tp)
{
if (tp->cb_type == T_ABS || tp->cb_type == T_SABS)
_drawlimit(tp);
}
/*
* cbredraw1 - redraw the bar as passed in.
*/
static void
cbredraw1(colorblock_t *cbp)
{
int i;
float offset;
float psize;
if (cbp->cb_mess) {
cbmessage(cbp, cbp->cb_mess);
return;
}
if (cbp->cb_type == T_SABS || cbp->cb_type == T_SREL)
cbredrawstrip(cbp);
else if (cbp->cb_type == T_NUM)
cbredrawnum(cbp);
else {
pushmatrix();
loadmatrix(cbp->cb_matrix);
offset = 0;
for (i = 0; i < cbp->cb_nsects; i++) {
psize = cbp->cb_aspect * cbp->cb_last[i];
color(cbp->cb_colors[i]);
rectf(offset, 0.0, offset + psize, 1.0);
offset += psize;
}
popmatrix();
}
if ((cbp->cb_type == T_ABS || cbp->cb_type == T_SABS))
if (cbp->cb_flags & (TF_MAX|TF_AVERAGE)) {
cbdrawmax(cbp);
}
}
static void
cbredrawstrip(colorblock_t *cbp)
{
int i;
strip_t *sp = cbp->cb_stp;
float *fp;
sp->st_cursamp = (sp->st_cursamp + 1) % sp->st_nsamples;
fp = sp->st_samples + (sp->st_cursamp * cbp->cb_nsects);
for (i = 0; i < cbp->cb_nsects; i++, fp++)
*fp = cbp->cb_last[i];
pushmatrix();
loadmatrix(cbp->cb_matrix);
if (inredraw || (cbp->cb_flags & TF_STRDR))
cbstredraw(cbp);
else
cbstquickdraw(cbp);
popmatrix();
}
static void
cbstredraw(colorblock_t *cbp)
{
int i;
int j;
strip_t *sp = cbp->cb_stp;
float offset;
float incr;
float height;
int start;
float *wf;
int whereseen = 0;
int toff;
int btoff;
incr = cbp->cb_aspect / sp->st_nsamples;
offset = 0;
cbp->cb_pixcross = 0;
if ((cbp->cb_flags & TF_WHERE) && sp->st_abswhere == sp->st_cursamp)
cbp->cb_flags &= ~TF_WHERE;
if (cbp->cb_flags & TF_TICK) {
toff = cbp->cb_tick - sp->st_tickcnt;
btoff = cbp->cb_bigtick - sp->st_bigtickcnt;
}
start = (sp->st_cursamp + 1) % sp->st_nsamples;
for (i = start; ; i = (i + 1) % sp->st_nsamples) {
height = 0;
wf = sp->st_samples + (i * cbp->cb_nsects);
for (j = 0; j < cbp->cb_nsects; j++) {
if (((cbp->cb_flags & TF_WHERE) && !whereseen) &&
j != cbp->cb_nsects - 1)
color(palecolor);
else
color(cbp->cb_colors[j]);
rectf(offset, height, offset + incr, (height + *wf));
height += *wf++;
}
if ((cbp->cb_flags & TF_WHERE) && sp->st_abswhere == i) {
color(RED);
move(offset+incr-cbp->cb_ftxwid, 0.0, 0.0);
draw(offset+incr-cbp->cb_ftxwid, 1.0, 0.0);
whereseen++;
}
if (cbp->cb_flags & TF_TICK) {
float npix;
toff--;
if (toff < 0) {
toff = cbp->cb_tick;
if (cbp->cb_flags & TF_BIGTICK) {
btoff--;
if (btoff < 0) {
btoff = cbp->cb_bigtick;
npix = TICKPER*2;
}
else
npix = TICKPER;
}
else
npix = TICKPER;
color(frontcolor);
move(offset, 1.0, 0.0);
draw(offset, 1.0-npix, 0.0);
}
}
offset += incr;
if (i == sp->st_cursamp)
break;
}
}
static void
cbstquickdraw(colorblock_t *cbp)
{
strip_t *sp = cbp->cb_stp;
float incr;
float *wf;
float fx;
float height;
float npix;
int i;
if (cbp->cb_flags & TF_SCHANGE) {
cbp->cb_flags &= ~TF_SCHANGE;
cbstredraw(cbp);
return;
}
incr = cbp->cb_aspect/sp->st_nsamples;
wf = sp->st_samples+(sp->st_cursamp*cbp->cb_nsects);
fx = cbp->cb_aspect - incr;
if (incr < cbp->cb_ftwid) {
cbp->cb_pixcross += incr;
if (cbp->cb_pixcross >= cbp->cb_ftwid) {
float tavg;
float nht;
float nfx;
for (tavg = 0, i = 0; i < cbp->cb_nsects; i++)
tavg += sp->st_avg[i]/sp->st_avgcnt;
tavg = 1.0 / tavg;
height = 0;
nfx = cbp->cb_aspect - cbp->cb_ftwid;
for (i = 0; i < cbp->cb_nsects; i++) {
color(cbp->cb_colors[i]);
nht = (sp->st_avg[i]/sp->st_avgcnt)*tavg;
rectf(nfx, height, nfx + cbp->cb_ftwid,
(height + nht));
height += nht;
sp->st_avg[i] = 0;
}
sp->st_avgcnt = 0;
if (sp->st_forcetick) {
float nfx;
if (sp->st_forcetick == 1)
npix = TICKPER;
else
npix = TICKPER*2;
sp->st_forcetick = 0;
nfx = cbp->cb_aspect - cbp->cb_ftwid;
color(frontcolor);
move(nfx, 1.0, 0.0);
draw(nfx, 1.0-npix, 0.0);
}
rectcopy(sp->st_irect[0], sp->st_irect[1],
sp->st_irect[2], sp->st_irect[3],
sp->st_fpos[0], sp->st_fpos[1]);
cbp->cb_pixcross = 0;
}
else {
float *twf = wf;
for (i = 0; i < cbp->cb_nsects; i++)
sp->st_avg[i] += *twf++;
sp->st_avgcnt++;
}
}
else {
rectcopy(sp->st_irect[0], sp->st_irect[1], sp->st_irect[2],
sp->st_irect[3], sp->st_fpos[0], sp->st_fpos[1]);
}
height = 0;
for (i = 0; i < cbp->cb_nsects; i++) {
color(cbp->cb_colors[i]);
rectf(fx, height, fx + incr, (height + *wf));
height += *wf++;
}
if (cbp->cb_flags & TF_TICK) {
sp->st_tickcnt++;
if (sp->st_tickcnt >= cbp->cb_tick) {
if (incr < cbp->cb_ftwid)
sp->st_forcetick = 1;
if (cbp->cb_flags & TF_BIGTICK) {
sp->st_bigtickcnt++;
if (sp->st_bigtickcnt >=
cbp->cb_bigtick) {
npix = TICKPER*2;
sp->st_bigtickcnt = 0;
if (incr < cbp->cb_ftwid)
sp->st_forcetick = 2;
}
else
npix = TICKPER;
}
else
npix = TICKPER;
sp->st_tickcnt = 0;
if (!sp->st_forcetick) {
color(frontcolor);
move(fx, 1.0, 0.0);
draw(fx, 1.0-npix, 0.0);
}
}
}
}
static void
cbdrawmax(colorblock_t *cbp)
{
if (cbp->cb_flags & TF_MAX) {
if (!inredraw) {
if (cbp->cb_max1 == 0)
goto checksum;
if (!(cbp->cb_flags & TF_REMAX))
goto checksum;
}
_drawmax(cbp);
}
checksum:
if (cbp->cb_flags & TF_AVERAGE) {
if (!inredraw) {
if (cbp->cb_lastavg1 == cbp->cb_dispavg1)
return;
cbp->cb_lastavg1 = cbp->cb_dispavg1;
}
_drawsum(cbp);
}
}
static void
cbredrawnum(colorblock_t *cbp)
{
char *dbuf;
float swid;
int i;
float ysc;
float sum;
int rv;
if (!(cbp->cb_flags & TF_NUMDISP))
if (!inredraw)
goto checkmax;
cbp->cb_flags &= ~TF_NUMDISP;
color(backcolor);
swid = cbp->cb_hdstart;
rectf(swid, cbp->cb_cposmid+halfpix(cbp), cbp->cb_cposx+cbp->cb_hdlen,
cbp->cb_cpostop);
color(frontcolor);
swid += rtfontinfo.xorig * cbp->cb_ftwid;
ysc = cbp->cb_cposmid + (rtfontinfo.yorig*cbp->cb_ftsywid);
sum = 0;
for (i = 0; i < cbp->cb_nsects - 1; i++) {
cmov2(swid, ysc);
dbuf = displaynum(cbp->cb_results[i], 0);
sum += cbp->cb_avg[i];
swid += (fmgetstrwidth(rtfont, cbp->cb_legend[i])*
cbp->cb_ftwid);
color(cbp->cb_colors[i]);
FMPRSTR(dbuf);
}
if ((rv = strlen(cbp->cb_legend[cbp->cb_nsects-1])) != 0) {
cmov2(swid, ysc);
dbuf = displaynum(cbp->cb_results[cbp->cb_nsects-1], 0);
color(cbp->cb_colors[i]);
FMPRSTR(dbuf);
}
if (cbp->cb_flags & TF_AVERAGE) {
if (rv) {
swid += (fmgetstrwidth(rtfont,
cbp->cb_legend[cbp->cb_nsects-1])*
cbp->cb_ftwid);
}
else
sum -= cbp->cb_avg[cbp->cb_nsects-2];
if (cbp->cb_flags & TF_MBSCALE)
dbuf = displaynum(sum, 1);
else
dbuf = displaynum(sum, 0);
strcat(dbuf, " ");
swid = swid + fmgetstrwidth(rtfont, AVGSTR)*cbp->cb_ftwid
- fmgetstrwidth(rtfont, dbuf)*cbp->cb_ftwid;
cmov2(swid, ysc);
color(frontcolor);
FMPRSTR(dbuf);
}
checkmax:
if (cbp->cb_flags & TF_MAX) {
if (!(cbp->cb_flags & TF_REMAX))
if (!inredraw)
return;
cbp->cb_flags &= ~TF_REMAX;
swid = cbp->cb_hdstart;
color(backcolor);
rectf(swid, cbp->cb_cposbot, cbp->cb_cposx+cbp->cb_hdlen,
cbp->cb_cposmid-halfpix(cbp));
ysc = cbp->cb_cposbot + (rtfontinfo.yorig * cbp->cb_ftsywid);
swid += rtfontinfo.xorig * cbp->cb_ftwid;
sum = 0;
color(cbp->cb_maxcol.front);
for (i = 0; i < cbp->cb_nsects - 1; i++) {
cmov2(swid, ysc);
dbuf = displaynum(cbp->cb_max[i], 0);
sum += cbp->cb_max[i];
swid += (fmgetstrwidth(rtfont, cbp->cb_legend[i])*
cbp->cb_ftwid);
FMPRSTR(dbuf);
}
if ((rv = strlen(cbp->cb_legend[cbp->cb_nsects-1])) != 0) {
cmov2(swid, ysc);
dbuf = displaynum(cbp->cb_max[i], 0);
FMPRSTR(dbuf);
}
if (cbp->cb_flags & TF_AVERAGE) {
if (rv) {
swid += (fmgetstrwidth(rtfont,
cbp->cb_legend[cbp->cb_nsects-1])*
cbp->cb_ftwid);
}
else
sum -= cbp->cb_avg[cbp->cb_nsects-2];
if (cbp->cb_flags & TF_MBSCALE)
dbuf = displaynum(sum, 1);
else
dbuf = displaynum(sum, 0);
strcat(dbuf, " ");
swid = swid +
fmgetstrwidth(rtfont, AVGSTR)*cbp->cb_ftwid
- fmgetstrwidth(rtfont, dbuf)*cbp->cb_ftwid;
cmov2(swid, ysc);
FMPRSTR(dbuf);
}
}
}
/*
* Put a message in the window for the user.
*/
void
cbmessage(colorblock_t *cbp, char *t)
{
if (t == 0) {
cbredraw1(cbp);
cbp->cb_mess = 0;
}
pushmatrix();
loadmatrix(cbp->cb_matrix);
color(WHITE);
rectf(0.0, 0.0, cbp->cb_aspect, 1.0);
cmov2(0.1, 0.3);
color(RED);
FMPRSTR(t);
popmatrix();
cbp->cb_mess = t;
}
static void
cbnumdraw(colorblock_t *cbp, int which, int just, float pstr) {
float y;
int back;
int front;
long swid;
float xcoff;
float ycoff;
char *str;
int scale = 0;
if (cbp->cb_flags & TF_MBSCALE)
scale = 1;
switch (which) {
case 0:
y = cbp->cb_cposbot;
back = cbp->cb_sumcol.back;
front = cbp->cb_sumcol.front;
break;
case 1:
y = cbp->cb_cposmid;
back = cbp->cb_maxcol.back;
front = cbp->cb_maxcol.front;
break;
case 2:
y = cbp->cb_cposy;
if (cbp->cb_flags & TF_NOSCALE) {
front = cbp->cb_limcol.back;
back = cbp->cb_limcol.front;
}
else {
back = cbp->cb_limcol.back;
front = cbp->cb_limcol.front;
}
break;
}
str = displaynum(pstr, scale);
xcoff = (rtfontinfo.xorig * cbp->cb_ftwid);
ycoff = (rtfontinfo.yorig * cbp->cb_ftsywid);
color(back);
rectf(cbp->cb_cmaxx, y, cbp->cb_cmaxx+cbp->cb_cmwid, y+cheight);
color(front);
swid = fmgetstrwidth(rtfont, str);
switch (just) {
case J_LEFT:
cmov2(cbp->cb_cmaxx+xcoff, y+ycoff);
FMPRSTR(str);
break;
case J_RIGHT:
cmov2((cbp->cb_cmaxx+cbp->cb_cmwid)-(swid*cbp->cb_ftwid),
y+ycoff);
FMPRSTR(str);
break;
}
if ((which == 2) && (cbp->cb_flags & TF_EXCEED)) {
color(RED);
rect(cbp->cb_cmaxx, y, cbp->cb_cmaxx+cbp->cb_cmwid, y+cheight);
color(RED);
}
}
/*
* Normalize a set of data points.
*/
static void
normalize(int size, float norm, float *array)
{
int i;
if (norm <= 0)
norm = 1.0;
else
norm = 1.0 / norm;
for (i = 0; i < size; i++)
array[i] *= norm;
}
static int
rollcopy(int size, float scale, float *old, double *new)
{
int i;
int ifc = 0;
float tmp;
for (i = 0; i < size; i++) {
tmp = fabs((scale*new[i])+((1-scale)*old[i]));
if (tmp != old[i]) {
ifc++;
old[i] = tmp;
}
}
return(ifc);
}
static int
frollcopy(int size, float scale, float *old, float *new)
{
int i;
int ifc = 0;
float tmp;
for (i = 0; i < size; i++) {
tmp = fabs((scale*new[i])+((1-scale)*old[i]));
if (tmp != old[i]) {
ifc++;
old[i] = tmp;
}
}
return(ifc);
}
/*
* barclamp - clamp the values to get a smooth movement out of the bar.
*/
static void
barclamp(colorblock_t *cbp, double *new)
{
(void) rollcopy(cbp->cb_nsects, cbp->cb_upmove, cbp->cb_results, new);
(void) frollcopy(cbp->cb_nsects, 1.0, cbp->cb_last, cbp->cb_results);
normalize(cbp->cb_nsects,unmasksum(cbp, cbp->cb_results), cbp->cb_last);
}
/*
* barmax - keep maximum value information before calling
* clamping function.
*/
static void
barmax(colorblock_t *cbp, double *new)
{
int i;
if (rollcopy(cbp->cb_nsects, 1.0, cbp->cb_results, new))
cbp->cb_flags |= TF_NUMDISP;
if (cbp->cb_flags & TF_AVERAGE) {
if (frollcopy(cbp->cb_nsects, 1.0/cbp->cb_avgtick, cbp->cb_avg,
cbp->cb_results)) {
cbp->cb_flags |= TF_REMAX;
cbp->cb_flags |= TF_NUMDISP;
}
}
if (cbp->cb_flags & TF_MAX) {
if (cbp->cb_flags & TF_MAXRESET) {
if (cbp->cb_maxcnt-- <= 0) {
for (i = 0; i < cbp->cb_nsects; i++)
cbp->cb_max[i] = 0;
cbp->cb_maxcnt = cbp->cb_maxtick;
cbp->cb_flags &= ~TF_MAXRESET;
}
}
for (i = 0; i < cbp->cb_nsects; i++) {
if (cbp->cb_results[i] > cbp->cb_max[i]) {
cbp->cb_flags |= TF_REMAX;
cbp->cb_max[i] = cbp->cb_results[i];
}
else if (!(cbp->cb_flags & TF_MAXRESET)) {
if (cbp->cb_maxtick <= 0)
continue;
if (cbp->cb_results[i] < cbp->cb_max[i]) {
if (cbp->cb_amax[i]-- <= 0) {
cbp->cb_max[i] = 0;
cbp->cb_amax[i] =
cbp->cb_maxtick;
}
}
else
cbp->cb_amax[i] = cbp->cb_maxtick;
}
}
}
}
/*
* barlimit - if a counter value exceeds the current maximum, re-scale.
*/
static void
barlimit(colorblock_t *cbp, double *new)
{
int i;
int tchg;
double sum;
double fullsum;
float cmax;
int nreal;
float scaler;
/*
* Normalize the data with the new numbers.
*/
if (strlen(cbp->cb_legend[cbp->cb_nsects-1]) == 0)
nreal = cbp->cb_nsects - 1;
else
nreal = cbp->cb_nsects;
rollcopy(cbp->cb_nsects, cbp->cb_upmove, cbp->cb_results, new);
if (cbp->cb_flags & TF_AVERAGE) {
rollcopy(nreal,1.0/cbp->cb_avgtick,cbp->cb_avg, new);
if (--cbp->cb_avgcnt <= 0) {
cmax = masksum(cbp, cbp->cb_avg);
cbp->cb_dispavg1 = cmax;
cbp->cb_avgcnt = cbp->cb_avgtick;
}
}
if (cbp->cb_flags & TF_MAX) {
if (cbp->cb_flags & TF_MAXRESET) {
rollcopy(nreal, 1.0, cbp->cb_max, new);
cmax = masksum(cbp, cbp->cb_max);
if (cbp->cb_maxcnt-- <= 0) {
cbp->cb_max1 = cbp->cb_dispmax = 0;
cbp->cb_flags &= ~TF_MAXRESET;
}
}
else
cmax = masksum(cbp, cbp->cb_results);
if (cmax < 0)
cmax = 0;
if (cmax > cbp->cb_max1) cbp->cb_max1 = cmax;
if (!(cbp->cb_flags & TF_MAXRESET) &&
cbp->cb_maxtick > 0) {
if (cmax < cbp->cb_dispmax) {
if (cbp->cb_maxcnt-- <= 0) {
cbp->cb_maxcnt = cbp->cb_maxtick;
cbp->cb_dispmax = cbp->cb_max1 = cmax;
cbp->cb_flags |= TF_REMAX;
}
}
else
cbp->cb_maxcnt = cbp->cb_maxtick;
}
if (cbp->cb_dispmax < cbp->cb_max1) {
cbp->cb_dispmax = cbp->cb_max1;
cbp->cb_flags |= TF_REMAX;
}
}
/*
* If a scale change is required, do so.
*/
sum = masksum(cbp, cbp->cb_results);
if (!(cbp->cb_flags & TF_NOSCALE)) {
tchg = 0;
if (cbp->cb_tlimit == 0 && sum <= cbp->cb_tlimit) {
cbp->cb_tlimit = sscale[0].disval;
cbdrawabs(cbp);
tchg++;
}
else if (sum > cbp->cb_tlimit) {
if (--cbp->cb_nabove <= 0) {
for (i = 0; i < MAXSCALE - 1 &&
sscale[i].disval < sum; i++);
cbp->cb_tlimit = sscale[i].disval;
cbdrawabs(cbp);
cbp->cb_nbelow = sscale[i].decay;
cbp->cb_nabove = sscale[i].advance;
cbp->cb_curscale = i;
tchg++;
}
}
else if (!(cbp->cb_flags & TF_CREEP)) {
if (cbp->cb_nbelow <= 0) {
for (i = 0; i < MAXSCALE - 1 &&
sscale[i].disval < sum; i++);
if (i < cbp->cb_curscale) {
cbp->cb_curscale--;
cbp->cb_tlimit =
sscale[cbp->cb_curscale].disval;
cbp->cb_nabove = sscale[i].advance;
cbdrawabs(cbp);
tchg++;
}
cbp->cb_nbelow = sscale[cbp->cb_curscale].decay;
}
else
cbp->cb_nbelow--;
}
if (tchg) {
if (cbp->cb_stp) {
cbp->cb_stp->st_abswhere =
cbp->cb_stp->st_cursamp;
cbp->cb_flags |= (TF_WHERE|TF_SCHANGE);
}
}
}
/*
* Finally, scale the actual values to match the scale factor.
*/
fullsum = 0;
for (i = 0; i < nreal; i++)
fullsum += cbp->cb_last[i] = cbp->cb_results[i];
if (nreal == cbp->cb_nsects - 1) {
if (fullsum > cbp->cb_tlimit) {
scaler = fullsum;
cbp->cb_last[nreal] = 0;
}
else {
scaler = cbp->cb_tlimit;
cbp->cb_last[nreal] = cbp->cb_tlimit - fullsum;
}
}
else {
fullsum += cbp->cb_last[cbp->cb_nsects]
= cbp->cb_results[cbp->cb_nsects];
scaler = fullsum;
}
if (sum > (cbp->cb_tlimit+(cbp->cb_tlimit*0.01))) {
if (!(cbp->cb_flags & TF_EXCEED)) {
cbp->cb_flags |= TF_EXCEED;
cbdrawabs(cbp);
}
}
else if (cbp->cb_flags & TF_EXCEED) {
cbp->cb_flags &= ~TF_EXCEED;
cbdrawabs(cbp);
}
normalize(cbp->cb_nsects, scaler, cbp->cb_last);
}
void
rtbar_text_end(void) {} /* end of text to lock down */
/*
* cbinit - create and initialize a new color bar. all you get from this
* call is a control block, not mapped to any screen position. the
* caller is responsible for initializing the transformation matrix and
* the color list.
*/
colorblock_t *
cbinit(void)
{
colorblock_t *tp;
if ((nbars % MAXBARS) == 0)
bars[nbars/MAXBARS] =
(colorblock_t *) calloc(sizeof(colorblock_t), MAXBARS);
tp = bars[nbars/MAXBARS] + (nbars % MAXBARS);
memset((void *) tp, 0, sizeof(*tp));
nbars++;
tp->cb_valid = 1;
tp->cb_rb = cbindex(tp);
return(tp);
}
/*
* cbindex - given a color bar pointer, return it's index
*/
int
cbindex(colorblock_t *cbp)
{
int i;
for (i = 0; i < MAXBARS; i++)
if (((long)cbp >= (long)bars[i]) &&
((long)cbp<((long)bars[i]+(MAXBARS*sizeof(colorblock_t)))))
return((i*MAXBARS) + (cbp - bars[i]));
return(-1);
}
/*
* cbptr - given an index, return a pointer to a color bar
*/
colorblock_t *
cbptr(int index) { return((bars[index/MAXBARS]) + (index % MAXBARS)); }
/*
* cbinitindex - initialize a color bar at a specific index
*/
colorblock_t *
cbinitindex(int index)
{
colorblock_t *tp;
if (bars[index/MAXBARS] == 0)
bars[index/MAXBARS] =
(colorblock_t *) calloc(sizeof(colorblock_t), MAXBARS);
tp = (bars[index/MAXBARS]) + (index % MAXBARS);
if (!tp->cb_valid) {
memset((void *) tp, 0, sizeof(colorblock_t));
tp->cb_valid = 1;
}
nbars++;
tp->cb_rb = index;
return(tp);
}
colorblock_t *
nextbar(int begin)
{
static int pos;
colorblock_t *tp;
if (begin) pos = 0;
for (;;) {
if (bars[pos/MAXBARS] == 0)
return(0);
tp = (bars[pos/MAXBARS]) + (pos % MAXBARS);
pos++;
if (tp->cb_valid)
return(tp);
}
}
/*
* cbstalloc - allocate space for the strip chart information.
*/
static void
cbstalloc(colorblock_t *cp, int n)
{
strip_t *sp;
float *wf;
int j;
int i;
if (cp->cb_stp == 0) {
cp->cb_stp = sp = (strip_t *) calloc(1, sizeof(strip_t));
cp->cb_pixcross = 0;
sp->st_nsamples = n;
sp->st_cursamp = n - 1;
sp->st_abswhere = 0;
sp->st_samples =
(float *) calloc(n, sizeof(float)*cp->cb_nsects);
for (i = 0; i < n; i++) {
wf = sp->st_samples + (i * cp->cb_nsects);
for (j = 0; j < cp->cb_nsects - 1; j++)
*wf++ = 0;
*wf = 1.0;
}
}
}
/*
* cblayout - once all bars are initialized, this function figures out
* all the display parameters for the window and bars and sets
* up the window.
*/
void
cblayout(char *title)
{
static int fontinit = 0;
int i;
int j;
colorblock_t *tp;
Screencoord ix;
Screencoord iy;
Screencoord six;
Screencoord siy;
Coord ywhere;
int wrow;
Coord offset;
int truncw = YSIZE;
int wcfontht;
static int old_wcfontht;
/*
* Open up the window.
*/
if (newwin) {
newwin = 0;
old_wcfontht = -9999;
/*
* First make sure we can find the font we wish to use.
*/
if (!fontinit) {
fminit();
fontinit = 1;
}
if (fontface == 0)
tfont = DEFFONT;
else
tfont = fontface;
if ((rtfont = fmfindfont(tfont)) == 0) {
fprintf(stderr, "%s: unable to find font \"%s\"\n",
pname, tfont);
exit(1);
}
if ((deffontfh = fmfindfont(DEFFONT)) == 0) {
/* default font not found?? not a disaster */
deffontfh = fmfindfont(tfont);
}
/*
* Now open up the window.
*/
if (!(title != 0 || do_border))
noborder();
if (debugger)
foreground();
wrow = (int)(((float) nbars / width) + 0.99);
/*
* Now deal with what the user said in laying it out.
* The rule is that arbsize is overruled by specifying
* the origin or preferred size.
*/
if (prefpos) {
if (prefwsize)
prefposition(prefxpos, prefxpos + prefxsize,
prefypos, prefypos + prefysize);
else
prefposition(prefxpos,
prefxpos + (MINXSIZE * width),
prefypos,
prefypos + (MINYSIZE * wrow));
}
else if (prefwsize)
prefsize(prefxsize, prefysize);
else if (!arbsize) {
if (debug)
fprintf(stderr, "width %d wrow %d aspect(%.2f,%d),size(%d,%d)\n",
width, wrow,
DEFXPERY*width, wrow,
MINXSIZE*width, MINYSIZE*wrow);
keepaspect((long)(DEFXPERY*100) * width, wrow * 100);
minsize(MINXSIZE * width, MINYSIZE * wrow);
}
fflush(logfd);
if (title != 0)
windes = winopen(title);
else
windes = winopen("gr_osview");
qdevice(LEFTMOUSE);
qdevice(WINQUIT);
qdevice(WINSHUT);
qdevice(WINFREEZE);
qdevice(WINTHAW);
qdevice(ESCKEY);
shademodel(FLAT);
} else {
winset(windes);
/*
* If not the first pass, we will need to re-scale the
* font, so discard what we had and start over.
*/
}
/*
* Shape the viewport and set up the base transformation.
*/
inredraw = 1;
cbwinsetup(0);
/*
* Determine the font size to use. The first step of this is to
* figure out where our window is on the screen.
*/
cmov2(0.0, 0.0);
GETCPOS(&ix, &iy);
cmov2(0.0, CHEIGHT);
GETCPOS(&six, &siy);
/*
if (debug || printpos)
printf("cp <%d,%d>, ch <%d,%d>, pixht <%d,%d>\n",
ix, iy, six, siy, six - ix, siy - iy);
*/
wcfontht = cbydist(iy, siy);
if (wcfontht <= 0)
wcfontht = 1;
{
fmfonthandle nfont = NULL;
double pntsz;
fmfonthandle ndeffont = NULL;
int alphasz;
if (wcfontht!=old_wcfontht) {
float pixinch;
fmfreefont(rtfont);
if ((rtfont = fmfindfont(tfont)) == 0) {
fprintf(stderr, "%s: unable to find font \"%s\"\n",
pname, tfont);
exit(1);
}
pixinch = (float)getgdesc(GD_YPMAX)/
((float)getgdesc(GD_YMMAX)*.03937);
pntsz = (wcfontht / pixinch) * PNTINCH;
if ((nfont = fmscalefont(rtfont, pntsz)) == 0) {
fprintf(stderr, "%s: unable to scale font \"%s\" to point size %f\n",
pname, tfont, pntsz);
exit(1);
}
alphasz = fmgetstrwidth(nfont, TALPHA);
if (strcmp(tfont, DEFFONT)) {
int defalphasz;
/*
* Since all 'tuning' for fit is done on the default
* font - we must tweak other fonts to fit
*/
if ((ndeffont = fmscalefont(deffontfh, pntsz)) == 0) {
fprintf(stderr, "%s: unable to scale font \"%s\" to point size %f\n",
pname, DEFFONT, pntsz);
exit(1);
}
defalphasz = fmgetstrwidth(ndeffont, TALPHA);
fmfreefont(ndeffont);
if (debug)
printf("pntsz %f defalphasz %d alphasz %d\n",
pntsz, defalphasz, alphasz);
while (alphasz > defalphasz) {
pntsz -= 0.25;
fmfreefont(nfont);
if ((nfont = fmscalefont(rtfont, pntsz)) == 0) {
fprintf(stderr, "%s: unable to scale font \"%s\" to pointsize %f\n",
pname, tfont, pntsz);
exit(1);
}
alphasz = fmgetstrwidth(nfont, TALPHA);
if (debug)
printf("pntsz %f defalphasz %d alphasz %d\n",
pntsz, defalphasz, alphasz);
}
}
fmgetfontinfo(nfont, &rtfontinfo);
fmfreefont(rtfont);
rtfont = nfont;
old_wcfontht=wcfontht;
/*
* alter real cheight based on font we really got
* oldC is to newC as old ht is to new ht
*/
cheight = ((float)rtfontinfo.ysize * CHEIGHT) / wcfontht;
bheight = ((float)rtfontinfo.yorig * CHEIGHT) / wcfontht;
if (debug) {
printf("wcfontht %d f.ysize %d f.yorig %d cheight %.2f, bheight %.2f\n",
wcfontht, rtfontinfo.ysize,
rtfontinfo.yorig, cheight, bheight);
printf("f.xsize %d f.xorig %d\n",
rtfontinfo.xsize, rtfontinfo.xorig);
}
}
}
fmsetfont(rtfont);
/*
* Now layout the bars in it.
*/
wrow = 0;
tp = nextbar(1);
while (tp != 0) {
/*
* Set up the bar space.
*/
ywhere = (Coord) (truncw - 1) - wrow + YBAROFF;
for (j = 0; j < width && tp != 0; j++, i++) {
/*
* Determine our position and set initial scaling.
*/
tp->cb_aspect = DEFXPERY;
offset = (DEFXPERY * (1.0-XSHRINK)) / 2.0;
tp->cb_xwhere = (DEFXPERY * j) + offset;
tp->cb_ywhere = ywhere;
pushmatrix();
translate(tp->cb_xwhere, tp->cb_ywhere, 0.0);
scale(XSHRINK, 1.0, 1.0);
cmov2(0.0, 0.0);
GETCPOS(&tp->cb_scrmask[0], &tp->cb_scrmask[2]);
cmov2(tp->cb_aspect, 1.0);
GETCPOS(&tp->cb_scrmask[1], &tp->cb_scrmask[3]);
getmatrix(tp->cb_matrix);
popmatrix();
cbonebar(tp);
if ((tp = nextbar(0)) == 0)
break;
}
wrow++;
}
/*
* Finalize the window.
*/
cbwinsetup(2);
inredraw = 0;
}
/*
* cbtakedown - destroy all window information and color bars.
*/
void
cbtakedown(void)
{
nbars = 0;
winclose(windes);
newwin = 1;
fmfreefont(rtfont);
}
static void
cbonebar(colorblock_t *tp)
{
Screencoord ix;
Screencoord iy;
Screencoord six;
Screencoord siy;
float xwhere = tp->cb_xwhere;
float ywhere = tp->cb_ywhere;
int border;
int j;
float psize;
long slen;
strip_t *sp;
float minx;
static int maxscreenx = -1;
/*
* If text supression was requested, then also suppress the
* max and average counters. For the scale, if it is locked,
* set the foreground and background to the bar background,
* making it invisible.
*/
if (nofont) {
tp->cb_flags &= ~(TF_MAX|TF_AVERAGE);
tp->cb_limcol.back = tp->cb_limcol.front = backcolor;
}
/*
* Now set up the character drawing space.
* Text is drawn in original world space, while bar drawing is
* done in a custom coordinate system.
*/
tp->cb_strwid = tp->cb_aspect * XSHRINK;
tp->cb_cposx = xwhere;
tp->cb_cposy = ywhere + YTEXTBASE;
tp->cb_cposz = 0.0;
psize = (YBARSCALE - (2 * cheight)) / 3;
tp->cb_cposbot = ywhere + psize;
tp->cb_cposmid = tp->cb_cposbot + cheight + psize;
tp->cb_cpostop = ywhere + YBARSCALE;
/*
* Setting this up is also affected by the brain-damaged rules
* in the GL for reflective window coordinates.
*/
cmov2(tp->cb_cposx, 0.0);
GETCPOS(&ix, &iy);
cmov2(tp->cb_cposx + tp->cb_strwid, 1.0);
GETCPOS(&six, &siy);
tp->cb_twid = six - ix;
tp->cb_ftwid = tp->cb_strwid / tp->cb_twid;
tp->cb_ftsywid = 1.0 / cbydist(iy, siy);
/*
* Figure out the maximum length of the text string area.
*/
slen = fmgetstrwidth(rtfont, tp->cb_header);
tp->cb_hdstart = tp->cb_cposx + (slen * tp->cb_ftwid);
for (j = 0; j < tp->cb_nsects; j++)
slen += fmgetstrwidth(rtfont, tp->cb_legend[j]);
if (tp->cb_type == T_NUM && (tp->cb_flags & TF_AVERAGE))
slen += fmgetstrwidth(rtfont, AVGSTR);
tp->cb_hdlen = (slen * tp->cb_ftwid);
/*
* Move drawing of bar to appropriate place.
*/
color(frontcolor);
linewidth((short) 1);
doscrmask(tp);
/*
* If an absolute limit display is in use, then calculate out
* the character positions.
*/
if (tp->cb_type == T_ABS || tp->cb_type == T_SABS) {
long swid;
float xv;
/*
* If the bar contains the side fields, then draw a rectangle
* around them now.
*/
swid = fmgetstrwidth(rtfont, "2222222");
tp->cb_cmaxx = tp->cb_cposx+tp->cb_strwid-
(tp->cb_cmwid = (swid*tp->cb_ftwid));
/*
rect(tp->cb_cmaxx-tp->cb_ftwid,
tp->cb_ywhere-tp->cb_ftsywid,
tp->cb_cposx+tp->cb_strwid+tp->cb_ftwid,
tp->cb_cposy+cheight+(2*tp->cb_ftsywid));
*/
pushmatrix();
loadmatrix(tp->cb_matrix);
if (tp->cb_flags & (TF_MAX|TF_AVERAGE)) {
/*
* A max value display requires that the bar be
* scaled down in size for room to display.
*/
xv = (tp->cb_strwid - tp->cb_cmwid) / tp->cb_aspect;
scale(xv, YBARSCALE, 1.0);
}
else
scale(1.0, YBARSCALE, 1.0);
}
else {
pushmatrix();
loadmatrix(tp->cb_matrix);
scale(1.0, YBARSCALE, 1.0);
}
/*
* Determine if a border is desired and set the clamping
* function.
*/
switch (tp->cb_type) {
case T_SABS:
if (tp->cb_flags & TF_NOBORD)
border = 0;
else
border = 1;
break;
case T_SREL:
if (tp->cb_flags & TF_NOBORD)
border = 0;
else
border = 1;
break;
case T_NUM:
border = 0; /* no lines at all */
popmatrix();
move(tp->cb_hdstart, tp->cb_cpostop + (2*tp->cb_ftsywid), 0.0);
draw(tp->cb_cposx + tp->cb_hdlen,
tp->cb_cpostop + (2*tp->cb_ftsywid),
0.0);
cmov2(tp->cb_cposx,
tp->cb_cposmid+(rtfontinfo.yorig*tp->cb_ftsywid));
color(frontcolor);
FMPRSTR("Current");
if (tp->cb_flags & TF_MAX) {
cmov2(tp->cb_cposx,
tp->cb_cposbot+(rtfontinfo.yorig*tp->cb_ftsywid));
color(tp->cb_maxcol.front);
FMPRSTR("Maximum");
}
pushmatrix();
loadmatrix(tp->cb_matrix);
break;
case T_ABS:
goto checkborder;
case T_REL:
default:
checkborder:
if (tp->cb_flags & TF_NOBORD)
border = 0; /* no border */
else
border = 2; /* real live hash marks */
break;
}
/*
* In bar space at this point. Get initial world/pixel ratio in Y.
*/
cmov2(0.0, 0.0);
GETCPOS(&ix, &iy);
cmov2(1.0, 1.0);
GETCPOS(&six, &siy);
tp->cb_ftywid = 1.0 / cbydist(iy, siy); /* one pixel in Y */
tp->cb_ftxwid = 1.0 / (six - ix); /* one pixel in X */
if (tp->cb_type == T_SREL || tp->cb_type == T_SABS) {
cbstalloc(tp, tp->cb_nsamp);
sp = tp->cb_stp;
cmov2(0.0, 0.0);
GETCPOS(&sp->st_fpos[0], &sp->st_fpos[1]);
sp->st_fpos[0] -= winposx;
sp->st_fpos[1] = cbydist(winposy, sp->st_fpos[1]);
}
/*
* Create the border around the bar.
*/
if (border == 2) {
float bmin;
float v[2];
/*
* Wide border with hash marks.
*/
rect(0.0, 0.0, tp->cb_aspect, 1.0);
bmin = 2.5 * tp->cb_ftywid;
if (bmin < BORDER) {
/*
* Largish window, easy to do.
*/
bmin = BORDER;
}
translate(tp->cb_ftxwid*2, bmin, 0.0);
scale(1-((tp->cb_ftxwid*3)/DEFXPERY), 1-(bmin+(tp->cb_ftywid)),
1.0);
/*
* Now go down the bar and add ticks marks in
* WHITE over the lower black border.
*/
color(frontcolor);
rectf(0.0, 0.0, tp->cb_aspect, -bmin);
color(WHITE);
psize = tp->cb_aspect / NDIVS;
for (j = 0; j <= NDIVS; j++) {
v[0] = j * psize;
bgnline();
v[1] = 0.0;
v2f(v);
v[1] = -bmin;
v2f(v);
endline();
}
if (tp->cb_type == T_SREL || tp->cb_type == T_SABS) {
sp->st_fpos[0]++;
sp->st_fpos[1] += 2;
}
}
else if (border == 1) {
/*
* Narrow border.
*/
rect(0.0, 0.0, tp->cb_aspect, 1.0);
/*
* Want exactly enough room for a one-pixel wide line
* around the bar.
*/
translate(tp->cb_ftxwid, tp->cb_ftywid, 0.0);
scale(1.0-((tp->cb_ftxwid*2)/DEFXPERY),
1.0-(tp->cb_ftywid*2), 1.0);
if (tp->cb_type == T_SREL || tp->cb_type == T_SABS) {
sp->st_fpos[0]++;
sp->st_fpos[1]++;
}
}
/*
* The bar was rescaled by drawing the border. Recalculate
* the pixel ratios.
*/
cmov2(0.0, 0.0);
GETCPOS(&ix, &iy);
cmov2(1.0, 1.0);
GETCPOS(&six, &siy);
tp->cb_ftywid = 1.0 / cbydist(iy, siy); /* one pixel in Y */
tp->cb_ftxwid = 1.0 / (six - ix); /* one pixel in X */
/*
* Now, if drawing a strip chart, figure out where the rectangles
* are in screen coordinates.
*/
if (tp->cb_type == T_SREL || tp->cb_type == T_SABS) {
/*
* Insure that the rectangle always copies at least one
* pixel's worth of stuff.
*/
minx = (tp->cb_ftwid > (tp->cb_aspect/sp->st_nsamples) ?
tp->cb_ftwid : (tp->cb_aspect/sp->st_nsamples));
cmov2(0.0+minx, 0.0);
GETCPOS(&sp->st_irect[0], &sp->st_irect[1]);
sp->st_irect[0] -= winposx;
sp->st_irect[1] = sp->st_fpos[1];
cmov2(tp->cb_aspect, 1.0);
GETCPOS(&sp->st_irect[2], &sp->st_irect[3]);
sp->st_irect[2] -= winposx;
sp->st_irect[3] = cbydist(winposy, sp->st_irect[3]);
if (printpos)
printf("irect[%d,%d,%d,%d], fpos[%d,%d]\n",
sp->st_irect[0], sp->st_irect[1],
sp->st_irect[2], sp->st_irect[3],
sp->st_fpos[0], sp->st_fpos[1]);
/*
* Disable the rectcopy if there's anything weird about
* where the window is.
*/
if (maxscreenx == -1)
maxscreenx = getgdesc(GD_XPMAX);
if (sp->st_irect[0] + winposx > maxscreenx ||
sp->st_irect[2] + winposx > maxscreenx ||
sp->st_fpos[0] + winposx > maxscreenx ||
sp->st_irect[0] < 0 ||
sp->st_irect[2] < 0 ||
sp->st_fpos[0] < 0)
tp->cb_flags |= TF_STRDR;
else
tp->cb_flags &= ~TF_STRDR;
}
getmatrix(tp->cb_matrix);
popmatrix();
/*
* Finally, perform any other random setup that needs to be
* done.
*/
}
/*
* cbwinsetup - responsible for initializing the window and laying out
* the bars and wording in a reasonable manner within it.
*/
static void
cbwinsetup(int x)
{
if (x < 2) {
/*
* Re-initialize the window in case it was moved.
*/
reshapeviewport();
getsize(&winsizex, &winsizey);
getorigin(&winposx, &winposy);
if (debug || printpos)
printf("Origin <%ld,%ld>, Size <%ld,%ld>\n",
winposx, winposy, winsizex, winsizey);
if (doublebuffered) {
backbuffer(TRUE);
frontbuffer(TRUE);
}
/*
* Set up world space matrix.
*/
viewport(0, winsizex-1, 0, winsizey-1);
color(backcolor);
clear();
ortho(0.0, (Coord) (DEFXPERY*width), 0.0,
(Coord) YSIZE, -1.0, 1.0);
if (debug)
printf("ortho 0,%f X 0,%f\n",
DEFXPERY*width, (double)YSIZE);
}
if (x) {
colorblock_t *tp;
/*
* Figure out where all
* the words should go and draw them.
*/
tp = nextbar(1);
while (tp != 0) {
doscrmask(tp);
cbdrawlegend(tp);
tp = nextbar(0);
}
scrmask(winposx, winposx+winsizex, winposy, winposy+winsizey);
/*
* Finally, if a message is present in any of the bars,
* then slam it out.
*/
tp = nextbar(1);
while (tp != 0) {
if (tp->cb_mess)
cbmessage(tp, tp->cb_mess);
tp = nextbar(0);
}
}
}
/*
* cbpreops - perform any pre-setup initialization needed.
*/
void
cbpreops(void)
{
frontcolor = BLACK;
backcolor = DEFBACKCOLOR;
palecolor = DEFPALECOLOR;
/*
* Make sure no color bars are allocated. If we ever go to dynamic
* allocation, this must free them all.
*/
nbars = 0;
/* we WILL lose memory here, unless you want to fix it ... */
}
/*
* cbresetbar - reset a colorbar for data
*/
void
cbresetbar(colorblock_t *cb)
{
int i;
cb->cb_flags |= TF_ONETRIP;
for (i = 0; i < MAXSECTS; i++) {
cb->cb_mess = 0;
cb->cb_max[i] = 0;
cb->cb_last[i] = 0;
cb->cb_avg[i] = 0;
cb->cb_results[i] = 0;
cb->cb_dispavg1 = cb->cb_lastavg1 = 0;
cb->cb_max1 = cb->cb_dispmax = 0;
cb->cb_nabove = 0;
cb->cb_nbelow = 0;
}
}
/*
* Routine to figure out the difference between two character positions,
* one of which may be in the GL's brain-damaged no-man's land.
*/
static int
cbydist(Screencoord iy, Screencoord siy)
{
int j;
static int ymax = 0;
if (ymax == 0)
ymax = getgdesc(GD_YPMAX);
if (siy < 0 && iy < 0) {
j = -iy + siy;
} else if (siy < iy) {
j = (ymax + siy) - iy;
} else {
j = siy - iy;
}
return(j);
}
View Git Blame Copy Permalink