int select_graph(Quark *gr)
{
if (quark_is_active(gr)) {
Project *pr = project_get_data(get_parent_project(gr));
if (pr) {
pr->cg = gr;
return RETURN_SUCCESS;
} else {
return RETURN_FAILURE;
}
} else {
return RETURN_FAILURE;
}
}
int write_ssd(const Quark *ssd, unsigned int ncols, const int *cols, FILE *fp)
{
char *sep = "\t";
unsigned int nrows = ssd_get_nrows(ssd), i, j;
unsigned int prec = project_get_prec(get_parent_project(ssd));
fputs("# ", fp);
for (j = 0; j < ncols; j++) {
char *lab = ssd_get_col_label(ssd, cols[j]);
if (j != 0) {
fputs(sep, fp);
}
fputs(lab ? lab:"?", fp);
}
fputs("\n", fp);
for (i = 0; i < nrows; i++) {
for (j = 0; j < ncols; j++) {
unsigned int col = cols[j];
ss_column *scol = ssd_get_col(ssd, col);
if (!scol) {
return RETURN_FAILURE;
}
if (j != 0) {
fputs(sep, fp);
}
if (scol->format == FFORMAT_STRING) {
char **s = ((char **) scol->data);
fprintf(fp, " \"%s\"", escapequotes(s[i]));
} else {
double *x = ((double *) scol->data);
fprintf(fp, "%.*g", prec, x[i]);
}
}
fputs("\n", fp);
}
fputs("\n", fp);
return RETURN_SUCCESS;
}
GProject *gproject_from_quark(const Quark *q)
{
unsigned int i;
GraceApp *gapp;
GProject *gp;
Quark *project = get_parent_project(q);
if (!project) {
return NULL;
}
gapp = gapp_from_quark(project);
for (i = 0; i < gapp->gpcount; i++) {
gp = gapp->gplist[i];
if (gproject_get_top(gp) == project) {
return gp;
}
}
return NULL;
}
static char *get_cell_content(SSDataUI *ui, int row, int column, int *format)
{
static char buf[STACKLEN][32];
static int stackp = 0;
int nrows = ssd_get_nrows(ui->q);
ss_column *col = ssd_get_col(ui->q, column);
char *s;
if (col && row >= 0 && row < nrows) {
unsigned int prec;
*format = col->format;
switch (col->format) {
case FFORMAT_STRING:
s = ((char **) col->data)[row];
break;
default:
prec = project_get_prec(get_parent_project(ui->q));
sprintf(buf[stackp], "%.*g", prec, ((double *) col->data)[row]);
s = buf[stackp];
stackp++;
stackp %= STACKLEN;
/* get rid of spaces */
while (s && *s == ' ') {
s++;
}
break;
}
} else {
s = "";
}
return s;
}
/*
* read data to the set from a file overriding the current contents
*/
int update_set_from_file(Quark *pset)
{
int retval;
Dataset *dsp;
dsp = set_get_dataset(pset);
if (!dsp) {
retval = RETURN_FAILURE;
} else {
FILE *fp;
RunTime *rt = rt_from_quark(pset);
fp = gapp_openr(gapp_from_quark(pset), dsp->hotfile, dsp->hotsrc);
killsetdata(pset);
rt->curtype = set_get_type(pset);
retval = uniread(get_parent_project(pset), fp, LOAD_SINGLE, dsp->hotfile);
gapp_close(fp);
}
return retval;
}
Quark *gapp_set_new(Quark *parent)
{
Quark *pset, *pr;
RunTime *rt;
pr = get_parent_project(parent);
pset = set_new(parent);
rt = rt_from_quark(pset);
if (!pset || !rt) {
return NULL;
}
rt->setcolor++;
rt->setcolor %= project_get_ncolors(pr);
if (rt->setcolor == 0) {
rt->setcolor = 1;
}
set_set_colors(pset, rt->setcolor);
return pset;
}
/*
* Arrange frames
*/
int arrange_frames(Quark **frames, int nframes,
int nrows, int ncols, int order, int snake,
double loff, double roff, double toff, double boff,
double vgap, double hgap,
int hpack, int vpack)
{
int i, imax, j, jmax, iw, ih, nf;
double pw, ph, w, h;
view v;
Quark *f, *pr;
if (!frames) {
return RETURN_FAILURE;
}
f = frames[0];
pr = get_parent_project(f);
if (!pr) {
return RETURN_FAILURE;
}
if (hpack) {
hgap = 0.0;
}
if (vpack) {
vgap = 0.0;
}
if (ncols < 1 || nrows < 1) {
errmsg("# of rows and columns must be > 0");
return RETURN_FAILURE;
}
if (hgap < 0.0 || vgap < 0.0) {
errmsg("hgap and vgap must be >= 0");
return RETURN_FAILURE;
}
project_get_viewport(pr, &pw, &ph);
w = (pw - loff - roff)/(ncols + (ncols - 1)*hgap);
h = (ph - toff - boff)/(nrows + (nrows - 1)*vgap);
if (h <= 0.0 || w <= 0.0) {
errmsg("Page offsets are too large");
return RETURN_FAILURE;
}
nf = 0;
if (order & GA_ORDER_HV_INV) {
imax = ncols;
jmax = nrows;
} else {
imax = nrows;
jmax = ncols;
}
for (i = 0; i < imax && nf < nframes; i++) {
for (j = 0; j < jmax && nf < nframes; j++) {
f = frames[nf];
if (order & GA_ORDER_HV_INV) {
iw = i;
ih = j;
if (snake && (iw % 2)) {
ih = nrows - ih - 1;
}
} else {
iw = j;
ih = i;
if (snake && (ih % 2)) {
iw = ncols - iw - 1;
}
}
if (order & GA_ORDER_H_INV) {
iw = ncols - iw - 1;
}
/* viewport y coord goes bottom -> top ! */
if (!(order & GA_ORDER_V_INV)) {
ih = nrows - ih - 1;
}
v.xv1 = loff + iw*w*(1.0 + hgap);
v.xv2 = v.xv1 + w;
v.yv1 = boff + ih*h*(1.0 + vgap);
v.yv2 = v.yv1 + h;
frame_set_view(f, &v);
nf++;
}
}
return RETURN_SUCCESS;
}
static int leaveCB(TableEvent *event)
{
SSDataUI *ui = (SSDataUI *) event->anydata;
int nrows = ssd_get_nrows(ui->q);
int ncols = ssd_get_ncols(ui->q);
int format;
double value;
int changed = FALSE;
GraceApp *gapp = gapp_from_quark(ui->q);
if (event->row < 0 || event->col < 0 || event->col > ncols) {
return TRUE;
}
if (event->row >= nrows && !string_is_empty(event->value)) {
if (ssd_set_nrows(ui->q, event->row + 1) == RETURN_SUCCESS) {
changed = TRUE;
}
}
if (event->col == ncols && !string_is_empty(event->value)) {
if (parse_date_or_number(get_parent_project(ui->q),
event->value, FALSE, get_date_hint(gapp), &value) == RETURN_SUCCESS) {
format = FFORMAT_NUMBER;
} else {
format = FFORMAT_STRING;
}
if (ssd_add_col(ui->q, format)) {
ncols++;
changed = TRUE;
}
}
if (event->col < ncols) {
char *old_value = get_cell_content(ui, event->row, event->col, &format);
if (!strings_are_equal(old_value, event->value)) {
switch (format) {
case FFORMAT_STRING:
if (ssd_set_string(ui->q, event->row, event->col, event->value) ==
RETURN_SUCCESS) {
quark_dirtystate_set(ui->q, TRUE);
changed = TRUE;
}
break;
default:
if (graal_eval_expr(grace_get_graal(gapp->grace),
event->value, &value, gproject_get_top(gapp->gp)) == RETURN_SUCCESS) {
unsigned int prec;
char buf[32];
double val;
prec = project_get_prec(get_parent_project(ui->q));
sprintf(buf, "%.*g", prec, value);
if (parse_date_or_number(get_parent_project(ui->q),
buf, FALSE, get_date_hint(gapp), &val) == RETURN_SUCCESS) {
if (ssd_set_value(ui->q, event->row, event->col, val) == RETURN_SUCCESS) {
quark_dirtystate_set(ui->q, TRUE);
changed = TRUE;
}
}
} else {
errmsg("Can't parse input value");
return FALSE;
}
break;
}
}
}
if (changed) {
snapshot_and_update(gapp->gp, FALSE);
}
return TRUE;
}
