/* file: text.c Paul Albrecht September 1987
Last revised: 14 November 2002
Text-handling functions for plt
Copyright (C) Paul Albrecht 1988
Recent changes (by George Moody, george@mit.edu):
30 March 2001: added label concatenation
11 April 2001: fixed nasty buffer overrun in MakeGraphTitle, general cleanup
21 October 2002: moved formerly global variables here from plt.h
14 November 2002: fixed missing casts in azmem calls
_______________________________________________________________________________
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
You may contact the maintainer by e-mail (george@mit.edu) or postal mail
(MIT Room E25-505A, Cambridge, MA 02139 USA). For updates to this software,
please visit PhysioNet (http://www.physionet.org/).
_______________________________________________________________________________
*/
#include <time.h>
#include "plt.h"
/* Font group object definition. */
typedef struct {
char *name; /* name of this font group */
char *font; /* name of the font */
double ps; /* point size of the font group */
double lw; /* line width for the font group */
double gray; /* gray scale: 0=black, 1=white */
char *lm; /* line mode associated with the font group */
char *color; /* color of the font */
char *gelem; /* where on the graph this font group is used */
} *FgPtr;
/* Prototypes of functions defined in this module. */
void TextInit(int psdel);
void MakeGraphTitle(char **argv);
void TextDraw(LblPtr l);
void ReadStrings(PStrPtr ps);
char *JustMap(char *userTbc);
void FontGroupSelect(char *dflt_fgName, char *fgName);
void FontGroupDef(char *fgName, char *specs);
int getstr(char **cpp, char **strp);
static FgPtr FontGroupCat(char *fgName, char *changes);
static void FontGroupModify(FgPtr fg, char *changes);
static FgPtr FontGroupFind(char *fgName, Boolean mustFind);
static FgPtr FontGroupInit(char *fgName);
static int getdbl(char **cpp, double *dblp);
static void checklm(FgPtr fg);
/* TextInit initalizes the font groups a, f, l, p, and t. Its single input
specifies how much the default point sizes should be increased (if psdel>0)
or decreased. plt's main function calls TextInit(0), and WindowDef calls
TextInit(-1) in order to decrease point sizes slightly when creating
subwindows. */
void TextInit(int psdel)
{
char changes[MAXLINE];
/* The "Ea", "Ef", etc. attributes are relics of the Masscomp bit-mapped
display driver from classic plt. They appear to be vestigial, but I've
left them in for now. -- GBM */
sprintf(changes, "P%g,W3,Ea", 14.0+psdel);
FontGroupDef("a", changes);
sprintf(changes, "P%g,W3,Ef", 14.0+psdel);
FontGroupDef("f", changes);
sprintf(changes, "P%g,W3,El", 15.0+psdel);
FontGroupDef("l", changes);
FontGroupDef("p", "P12,W2,Ep");
sprintf(changes, "P%g,W4,Et", 16.0+psdel);
FontGroupDef("t", changes);
}
/* Draw the plot title (creating one if none was specified). */
void MakeGraphTitle(char **argv)
{
Ptype n, x, y, xsize, ysize;
char *ptr, *ctime(), *getenv(), str[50], titleText[60], title2[40];
int alen, targmax;
time_t seconds;
if (!(omode & TITLES))
return;
if (title.text == 0) {
/* No title specified by user -- generate a title from the argument list,
user name, date, and time. */
titleText[0] = 0;
/* Generate the end of the title first. */
strcpy(title2, "-- <");
if (ptr = getenv("LOGNAME")) {
strncat(title2, ptr, 20);
strcat(title2, "-");
}
time(&seconds);
strftime(title2+strlen(title2), 14, "%H:%M-%b %e>", localtime(&seconds));
targmax = sizeof(titleText)-strlen(title2)-6; /* allow space for " ... " */
ptr = titleText;
/* Allow up to targmax characters from the argument list in the title. */
while (*argv) {
int titlelen = 0;
if (titlelen + (alen = strlen(*argv)) < targmax) {
strcpy(ptr, *argv++);
ptr += alen;
*ptr++ = ' ';
titlelen += alen+1;
}
else {
strncpy(ptr, *argv, alen = targmax - titlelen);
ptr += alen;
strcpy(ptr, " ... ");
ptr += 5;
break;
}
}
strcpy(ptr, title2);
title.text = titleText;
}
else if (strlen(title.text) == 0)
return;
FontGroupSelect("t", title.fgName);
x = (xwmin + xwmax)/2;
if (theight == 0) {
strsize(title.text, &xsize, &ysize, 0.0);
y = ywmax + (int)((yfract+0.4)*ysize + yfract*yinch/12);
title.just = "CC"; /* changed from "CB" -- GBM */
}
else y = ywmin + (int)((ywmax-ywmin)*theight);
plabel(title.text, x, y, title.just, 0.0);
}
/* Draw a user-defined label. */
void TextDraw(LblPtr l)
{
short n, nc = 0, x, y, xsize, ysize;
char c = 1, lbl[MAXLINE];
if (l->text == 0 || *l->text == 0)
return;
FontGroupSelect("l", l->fgName);
transform(&x, &y, l->xpos, l->ypos, 0.5, l->coord);
if (l->xpos == DEFAULT) x = DEFAULT;
if (l->ypos == DEFAULT) y = DEFAULT;
while (c) {
n = 0;
do {
c = l->text[nc++];
lbl[n++] = (c == '\n') ? 0 : c;
} while (c && c != '\n');
plabel(lbl, x, y, l->just, l->angle);
strsize(lbl, &xsize, &ysize, l->angle);
if (fabs(l->angle) < 1) {
if (y != DEFAULT) y -= ysize;
}
else
if (x != DEFAULT) x += xsize;
}
}
/* Read or append to a string array. */
void ReadStrings(PStrPtr ps)
{
FILE *fp;
short k;
char c, *str, line[200];
if (ps->file) {
fp = fopen(ps->str, "r");
if (fp == 0) err(YES, "Can't open string file %s", ps->str);
}
else str = ps->str;
while (YES) {
if (ps->file) {
if (fgets(line, sizeof(line), fp) == NULL) break;
k = strlen(line);
if (line[k-1] == '\n') line[k-1] = 0;
}
else {
if (*str == 0) break;
for (k = 0; (c = str[k]) && c != ' ' && c != '\n'; k++)
line[k] = c;
line[k] = 0;
str += (c == 0) ? k : k+1;
}
if (ps->n == ps->nmax)
ps->list = (char **)azmem(ps->list, (size_t *)&ps->nmax, 50,
sizeof(*ps->list));
ps->list[ps->n++] = StringSave(line);
}
ps->just = (ps->just == 0) ? "CC" : JustMap(ps->just);
if(ps->file) fclose(fp);
}
/* Convert a text box coordinate to a two character string. */
char *JustMap(char *userTbc)
{
static char tbc[3];
short n;
for (n = 0; n < 2; n++) {
tbc[n] = (userTbc[n] == 0) ? 0 : userTbc[n];
if ('a' <= tbc[n] && tbc[n] <= 'z')
tbc[n] += 'A' - 'a';
}
if (!tbc[1]) {
/* This block of code supports obsolete syntax and will be removed in
a future release. */
switch (tbc[0]) {
case 'C': tbc[1] = 'C'; break;
case 'D': tbc[0] = 'L'; /* fall through to case 'L' */
case 'L': tbc[1] = 'B'; break;
case 'U': tbc[0] = 'R'; /* fall through to case 'R' */
case 'R': tbc[1] = 'B'; break;
default: err(YES, "unrecognized text box coordinate `%s'\n", userTbc);
break;
}
err(NO, "Warning: obsolete text box coordinate `%s' converted to `%s'\n",
userTbc, tbc);
}
return (StringSave(tbc));
}
/* Set font type, point size, etc. */
void FontGroupSelect(char *dflt_fgName, char *fgName)
{
PtrUnion arg0, arg1;
FgPtr fg;
double scl;
if (fgName != 0) {
if ((fg=FontGroupFind(fgName,NO)) == 0)
/* use fgName as changes to make to default fgroup */
fg = FontGroupCat(dflt_fgName, fgName);
}
else {
if (dflt_fgName == 0)
err(YES, "Bad call to FontGroupSelect()");
fg = FontGroupFind(dflt_fgName, YES);
}
/* The "graph element" is a relic of the Masscomp bitmap display driver from
classic plt. It appears to be vestigial, but I've left it in for now.
-- GBM */
arg0.c = fg->gelem;
special(GRAPHELEMENT, arg0, arg1);
/* Set the line mode (solid, dotted, etc.; but only if it hasn't been
changed). This must be done before setting the point size, according
to an old comment found here -- but why? */
if (strcmp(old_lm,fg->lm) != 0) {
arg0.c = fg->lm;
special(SETLINEMODE, arg0, arg1);
}
/* Set the grey level, if it hasn't been set previously or if it has
changed. The interaction with the color setting is tricky. */
if (oldGrayLevel < 0 || oldGrayLevel != fg->gray) {
static char colorstring[8];
oldGrayLevel = fg->gray;
arg0.d = &oldGrayLevel;
special(SETGRAY, arg0, arg1);
sprintf(colorstring, "gray%02d", (int)(oldGrayLevel*100));
fg->color = colorstring;
}
/* Set the foreground color. (The background color is always white in the
current version of plt.) */
if (fg->color != NULL && *fg->color != '\0') {
arg0.c = fg->color;
special(SETCOLOR, arg0, arg1);
}
/* Set the line width, if it hasn't been set previously or if it has
changed. */
if (old_lw < 0 || old_lw != fg->lw) {
old_lw = fg->lw;
arg0.d = &old_lw;
special(SETLINEWIDTH, arg0, arg1);
}
/* Set the point size and the font family if they have not been set
previously or if either has changed. */
if (!fixed_font &&
!(old_font && strcmp(fg->font, old_font) == 0 && fg->ps == old_ps)) {
scl = fg->ps/default_ps;
chht = p->ch * scl + 0.5;
chwd = p->cw * scl + 0.5;
old_font = fg->font;
old_ps = fg->ps;
arg0.c = old_font;
arg1.d = &old_ps;
special(SETFONT, arg0, arg1);
}
}
/* Define the parameters for a font group. */
void FontGroupDef(char *fgName, char *specs)
{
if (specs) {
if (fgName == 0 || strcmp(fgName,"all") == 0) {
FontGroupDef("a", specs);
FontGroupDef("f", specs);
FontGroupDef("l", specs);
FontGroupDef("p", specs);
FontGroupDef("t", specs);
}
else {
FgPtr fg;
if ((fg=FontGroupFind(fgName, NO)) == 0)
fg = FontGroupInit(fgName);
FontGroupModify(fg, specs);
}
}
}
/* Create a new font group as a modified version of an old one. */
static FgPtr FontGroupCat(char *fgName, char *changes)
{
FgPtr fg, FontGroupInit();
char *newfgName = zmem(1, strlen(fgName) + strlen(changes) + 1);
sprintf(newfgName, "%s%s", fgName, changes);
if (fg = FontGroupFind(newfgName, NO)) return (fg);
fg = FontGroupInit(newfgName);
*fg = *FontGroupFind(fgName, YES);
fg->name = StringSave(newfgName);
FontGroupModify(fg, changes);
return (fg);
}
/* Modify an existing font group according to the specs in `changes'. */
static void FontGroupModify(FgPtr fg, char *changes)
{
FgPtr fgnew;
short errFlag = NO;
char *cp = changes, *fgName;
/* Skip opening parenthesis or bracket if present. */
if (*cp == '(' || *cp == '[') cp++;
while (*cp) {
if (*cp == ')' || *cp == ']') {
cp++;
while (*cp == ' ')
cp++;
if (*cp == 0)
break;
/* go get the error */
}
switch (*cp++) {
case ' ':
case ',':
case '\t':
break;
case GCOLOR:
errFlag |= !getstr(&cp, &fg->color);
break;
case GELEMENT: /* vestigial, see comments above */
errFlag |= !getstr(&cp, &fg->gelem);
break;
case GFONT:
errFlag |= !getstr(&cp, &fg->font);
break;
case GGRAY:
errFlag |= !getdbl(&cp,&fg->gray);
if (fg->gray > 1) fg->gray = 1;
break;
case GLINEMODE:
errFlag |= !getstr(&cp, &fg->lm);
checklm(fg);
break;
case GPS:
errFlag |= !getdbl(&cp, &fg->ps);
break;
case GLINEWIDTH:
errFlag |= !getdbl(&cp, &fg->lw);
break;
default:
cp--;
errFlag |= !getstr(&cp, &fgName);
fgnew = FontGroupFind(fgName, NO);
if (fgnew == 0) errFlag = YES;
else {
fgName = fg->name;
*fg = *fgnew;
fg->name = fgName;
}
break;
}
if (errFlag) {
err(YES, "Font group syntax error `%s'", changes);
break;
}
}
}
static FgPtr fgrps;
static Uint nfgrps;
static FgPtr FontGroupFind(char *fgName, Boolean mustFind)
{
FgPtr fg;
short n;
for (n = 0; n < nfgrps; n++) {
fg = &fgrps[n];
if (strcmp(fg->name, fgName) == 0)
return (fg);
}
if (mustFind)
err(YES, "No font group `%s'", fgName);
return (0);
}
static FgPtr FontGroupInit(char *fgName)
{
FgPtr fg;
static Uint maxfgrps;
if (nfgrps == maxfgrps)
fgrps = (FgPtr)azmem(fgrps, (size_t *)&maxfgrps, 6, sizeof(*fgrps));
fg = &fgrps[nfgrps++];
fg->name = fgName;
fg->font = DEFAULT_FONT;
fg->ps = DEFAULT_PS;
fg->lw = DEFAULT_LW;
fg->gray = PS_BLACK;
fg->lm = "solid";
fg->color = "black";
fg->gelem = "";
return (fg);
}
int getstr(char **cpp, char **strp)
{
short n;
char *cp, str[MAXLINE];
while (**cpp == ' ')
(*cpp)++;
n = 0;
cp = *cpp;
while (*cp) {
if (*cp == ' ' || *cp == ',' || *cp == ')' || *cp == ']')
break;
str[n++] = *cp++;
}
str[n] = 0;
if (*cpp != cp) {
*cpp = cp;
*strp = StringSave(str);
return (YES);
}
else return (NO);
}
static int getdbl(char **cpp, double *dblp)
{
double dbl, dec;
char *cp, operation;
while (**cpp == ' ')
(*cpp)++;
dbl = 1e-6;
cp = *cpp;
if (*cp == '+' || *cp == '-' || *cp == '*' || *cp == '/')
operation = *cp++;
else
operation = 0;
while ('0' <= *cp && *cp <= '9') {
dbl = 10*dbl + ((*cp++ -'0')&0177);
}
if (*cp == '.') {
dec = .1;
cp++;
while ('0' <= *cp && *cp <= '9') {
dbl += dec * ((*cp++ -'0')&0177);
dec *= 0.1;
}
}
if (*cpp != cp) {
*cpp = cp;
switch(operation) {
case '+': *dblp += dbl; break;
case '-': *dblp -= dbl; break;
case '*': *dblp *= dbl; break;
case '/': *dblp /= dbl; break;
default: *dblp = dbl; break;
}
return (YES);
}
else return (NO);
}
static void checklm(FgPtr fg)
{
static struct {
char *name;
short n;
} *l, lm[] = { /* the first 5 must appear first !!!!!!! ... */
"solid", 0,
"dotted", 1,
"shortdashed", 2,
"dotdashed", 3,
"longdashed", 4,
"0", 0,
"1", 1,
"2", 2,
"3", 3,
"4", 4,
"5", 5,
"dash", 2 };
for (l = lm; l < ENDP(lm); l++)
if (strcmp(l->name, fg->lm) == 0 ||
strncmp(l->name, fg->lm, strlen(fg->lm)) == 0) {
fg->lm = lm[l->n].name; /* ... and this is why !!!!!!!! */
return;
}
err(YES, "No linemode type `%s'", fg->lm);
}