int set_object_data(ObjectUI *ui, Quark *q, void *caller)
{
DObject *o = object_get_data(q);
if (o && ui) {
if (!caller || caller == ui->x) {
xv_evalexpr(ui->x, &o->ap.x);
}
if (!caller || caller == ui->y) {
xv_evalexpr(ui->y, &o->ap.y);
}
if (!caller || caller == ui->offsetx) {
o->offset.x = SpinChoiceGetValue(ui->offsetx);
}
if (!caller || caller == ui->offsety) {
o->offset.y = SpinChoiceGetValue(ui->offsety);
}
if (!caller || caller == ui->angle) {
o->angle = GetAngleChoice(ui->angle);
}
if (!caller || caller == ui->linew) {
o->line.width = SpinChoiceGetValue(ui->linew);
}
if (!caller || caller == ui->lines) {
o->line.style = GetOptionChoice(ui->lines);
}
if (!caller || caller == ui->linepen) {
GetPenChoice(ui->linepen, &o->line.pen);
}
if (!caller || caller == ui->fillpen) {
GetPenChoice(ui->fillpen, &o->fillpen);
}
switch (o->type) {
case DO_LINE:
set_line_odata(ui->line_ui, (DOLineData *) o->odata, caller);
break;
case DO_BOX:
set_box_odata(ui->box_ui, (DOBoxData *) o->odata, caller);
break;
case DO_ARC:
set_arc_odata(ui->arc_ui, (DOArcData *) o->odata, caller);
break;
default:
break;
}
quark_dirtystate_set(q, TRUE);
return RETURN_SUCCESS;
} else {
return RETURN_FAILURE;
}
}
/*
* This CB services the axis "Scale" selector
*/
static void axis_scale_cb(OptionStructure *opt, int value, void *data)
{
int scale = value;
double axestart, axestop;
char buf[32];
TextStructure *axis_world_start;
TextStructure *axis_world_stop;
ExplorerUI *eui = (ExplorerUI *) data;
GraphUI *ui = eui->graph_ui;
if (opt == ui->scale_x) {
axis_world_start = ui->start_x;
axis_world_stop = ui->stop_x;
} else {
axis_world_start = ui->start_y;
axis_world_stop = ui->stop_y;
}
xv_evalexpr(axis_world_start, &axestart) ;
xv_evalexpr(axis_world_stop, &axestop);
switch (scale) {
case SCALE_LOG:
if (axestart <= 0.0 && axestop <= 0.0) {
errmsg("Can't set logarithmic scale for negative coordinates");
SetOptionChoice(opt, SCALE_NORMAL);
return;
} else if (axestart <= 0.0) {
axestart = axestop/1.0e3;
sprintf(buf, "%g", axestart);
TextSetString(axis_world_start, buf);
}
break;
case SCALE_LOGIT:
if (axestart <= 0.0 && axestop <= 0.0) {
errmsg("Can't set logit scale for values outside 0 and 1");
SetOptionChoice(opt, SCALE_NORMAL);
return;
}
if (axestart <= 0.0) {
axestart = 0.1;
sprintf(buf, "%g", axestart);
TextSetString(axis_world_start, buf);
}
if (axestop >= 1.0) {
axestop = 0.95;
sprintf(buf, "%g", axestop);
TextSetString(axis_world_stop, buf);
}
break;
}
}
static void do_units_toggle(OptionStructure *opt, int value, void *data)
{
ProjectUI *ui = (ProjectUI *) data;
char buf[32];
double page_x, page_y;
int page_units = value;
if (xv_evalexpr(ui->page_x, &page_x) != RETURN_SUCCESS ||
xv_evalexpr(ui->page_y, &page_y) != RETURN_SUCCESS ) {
errmsg("Invalid page dimension(s)");
return;
}
if (ui->current_page_units == page_units) {
return;
}
switch (ui->current_page_units) {
case PAGE_UNITS_IN:
page_x *= 72.0;
page_y *= 72.0;
break;
case PAGE_UNITS_CM:
page_x *= 72.0/CM_PER_INCH;
page_y *= 72.0/CM_PER_INCH;
break;
}
switch (page_units) {
case PAGE_UNITS_IN:
page_x /= 72.0;
page_y /= 72.0;
break;
case PAGE_UNITS_CM:
page_x /= 72.0/CM_PER_INCH;
page_y /= 72.0/CM_PER_INCH;
break;
}
ui->current_page_units = page_units;
sprintf (buf, "%.2f", page_x);
TextSetString(ui->page_x, buf);
sprintf (buf, "%.2f", page_y);
TextSetString(ui->page_y, buf);
}
static void do_orient_toggle(OptionStructure *opt, int value, void *data)
{
ProjectUI *ui = (ProjectUI *) data;
double px, py;
char buf[32];
int orientation = value;
if (xv_evalexpr(ui->page_x, &px) != RETURN_SUCCESS ||
xv_evalexpr(ui->page_y, &py) != RETURN_SUCCESS ) {
errmsg("Invalid page dimension(s)");
return;
}
if ((orientation == PAGE_ORIENT_LANDSCAPE && px < py) ||
(orientation == PAGE_ORIENT_PORTRAIT && px > py) ) {
sprintf (buf, "%.2f", py);
TextSetString(ui->page_x, buf);
sprintf (buf, "%.2f", px);
TextSetString(ui->page_y, buf);
}
}
static int leval_aac_cb(void *data)
{
int i, nscols, type;
double start, stop;
int npts;
char *formula[MAX_SET_COLS];
Quark *pset, *gr;
GVar *t;
Leval_ui *ui = (Leval_ui *) data;
Grace *grace;
gr = ui->gr;
type = GetOptionChoice(ui->set_type);
nscols = settype_cols(type);
if (xv_evalexpr(ui->start, &start) != RETURN_SUCCESS) {
errmsg("Start item undefined");
return RETURN_FAILURE;
}
if (xv_evalexpr(ui->stop, &stop) != RETURN_SUCCESS) {
errmsg("Stop item undefined");
return RETURN_FAILURE;
}
if (xv_evalexpri(ui->npts, &npts) != RETURN_SUCCESS) {
errmsg("Number of points undefined");
return RETURN_FAILURE;
}
TableCommitEdit(ui->mw, FALSE);
for (i = 0; i < nscols; i++) {
formula[i] = TableGetCell(ui->mw, i, 0);
}
pset = gapp_set_new(gr);
set_set_type(pset, type);
grace = grace_from_quark(pset);
t = graal_get_var(grace_get_graal(grace), "$t", TRUE);
if (t == NULL) {
errmsg("Internal error");
return RETURN_FAILURE;
}
#if 0
if (t->length != 0) {
xfree(t->data);
t->length = 0;
}
t->data = allocate_mesh(start, stop, npts);
if (t->data == NULL) {
return RETURN_FAILURE;
}
t->length = npts;
if (set_set_length(pset, npts) != RETURN_SUCCESS) {
quark_free(pset);
XCFREE(t->data);
t->length = 0;
return RETURN_FAILURE;
}
#endif
for (i = 0; i < nscols; i++) {
char buf[32], *expr;
int res;
/* preparing the expression */
sprintf(buf, "%s = ", dataset_col_name(grace, i));
expr = copy_string(NULL, buf);
expr = concat_strings(expr, formula[i]);
/* evaluate the expression */
res = graal_parse_line(grace_get_graal(grace), expr, NULL);
xfree(expr);
if (res != RETURN_SUCCESS) {
quark_free(pset);
return RETURN_FAILURE;
}
}
#if 0
XCFREE(t->data);
t->length = 0;
#endif
update_set_lists(gr);
return RETURN_SUCCESS;
}
int set_axisgrid_data(AGridUI *ui, Quark *q, void *caller)
{
tickmarks *t = axisgrid_get_data(q);
if (t && ui) {
AMem *amem = quark_get_amem(q);
int i;
if (!caller || caller == ui->type) {
t->type = GetOptionChoice(ui->type);
}
if (!caller || caller == ui->tmajor) {
if (xv_evalexpr(ui->tmajor, &t->tmajor) != RETURN_SUCCESS) {
errmsg("Specify major tick spacing");
return RETURN_FAILURE;
}
}
if (!caller || caller == ui->nminor) {
t->nminor = (int) SpinChoiceGetValue(ui->nminor);
}
if (!caller || caller == ui->tlform) {
Format *format = GetFormatChoice(ui->tlform);
AMem *amem = quark_get_amem(q);
amem_free(amem, t->tl_format.fstring);
t->tl_format = *format;
t->tl_format.fstring = amem_strdup(amem, format->fstring);
format_free(format);
}
if (!caller || caller == ui->tlfont) {
t->tl_tprops.font = GetOptionChoice(ui->tlfont);
}
if (!caller || caller == ui->tlcolor) {
t->tl_tprops.color = GetOptionChoice(ui->tlcolor);
}
if (!caller || caller == ui->barpen) {
GetPenChoice(ui->barpen, &t->bar.pen);
}
if (!caller || caller == ui->barlinew) {
t->bar.width = SpinChoiceGetValue(ui->barlinew);
}
if (!caller || caller == ui->barlines) {
t->bar.style = GetOptionChoice(ui->barlines);
}
if (!caller || caller == ui->tlcharsize) {
t->tl_tprops.charsize = SpinChoiceGetValue(ui->tlcharsize);
}
if (!caller || caller == ui->tlangle) {
t->tl_tprops.angle = GetAngleChoice(ui->tlangle);
}
if (!caller || caller == ui->tlstagger) {
t->tl_staggered = GetOptionChoice(ui->tlstagger);
}
if (!caller || caller == ui->tlstarttype) {
t->tl_starttype = GetOptionChoice(ui->tlstarttype) == 0 ?
TYPE_AUTO : TYPE_SPEC;
}
if (!caller || caller == ui->tlstart) {
if (t->tl_starttype == TYPE_SPEC) {
if (xv_evalexpr(ui->tlstart, &t->tl_start) != RETURN_SUCCESS) {
errmsg("Specify tick label start");
return RETURN_FAILURE;
}
}
}
if (!caller || caller == ui->tlstoptype) {
t->tl_stoptype = GetOptionChoice(ui->tlstoptype) == 0 ?
TYPE_AUTO : TYPE_SPEC;
}
if (!caller || caller == ui->tlstop) {
if (t->tl_stoptype == TYPE_SPEC) {
if (xv_evalexpr(ui->tlstop, &t->tl_stop) != RETURN_SUCCESS) {
errmsg("Specify tick label stop");
return RETURN_FAILURE;
}
}
}
if (!caller || caller == ui->tlskip) {
t->tl_skip = GetOptionChoice(ui->tlskip);
}
if (!caller || caller == ui->tlformula) {
char *s = TextGetString(ui->tlformula);
t->tl_formula = amem_strcpy(amem, t->tl_formula, s);
xfree(s);
}
if (!caller || caller == ui->tlprestr) {
char *s = TextGetString(ui->tlprestr);
t->tl_prestr = amem_strcpy(amem, t->tl_prestr, s);
xfree(s);
}
if (!caller || caller == ui->tlappstr) {
char *s = TextGetString(ui->tlappstr);
t->tl_appstr = amem_strcpy(amem, t->tl_appstr, s);
xfree(s);
}
if (!caller || caller == ui->tlgap_para) {
xv_evalexpr(ui->tlgap_para, &t->tl_gap.x);
}
if (!caller || caller == ui->tlgap_perp) {
xv_evalexpr(ui->tlgap_perp, &t->tl_gap.y);
}
if (!caller || caller == ui->tround) {
t->t_round = ToggleButtonGetState(ui->tround);
}
if (!caller || caller == ui->autonum) {
t->t_autonum = GetOptionChoice(ui->autonum) + 2;
}
if (!caller || caller == ui->tgrid) {
t->gprops.onoff = ToggleButtonGetState(ui->tgrid);
}
if (!caller || caller == ui->tgridpen) {
GetPenChoice(ui->tgridpen, &t->gprops.line.pen);
}
if (!caller || caller == ui->tgridlinew) {
t->gprops.line.width = SpinChoiceGetValue(ui->tgridlinew);
}
if (!caller || caller == ui->tgridlines) {
t->gprops.line.style = GetOptionChoice(ui->tgridlines);
}
if (!caller || caller == ui->tmgrid) {
t->mgprops.onoff = ToggleButtonGetState(ui->tmgrid);
}
if (!caller || caller == ui->tmgridpen) {
GetPenChoice(ui->tmgridpen, &t->mgprops.line.pen);
}
if (!caller || caller == ui->tmgridlinew) {
t->mgprops.line.width = SpinChoiceGetValue(ui->tmgridlinew);
}
if (!caller || caller == ui->tmgridlines) {
t->mgprops.line.style = GetOptionChoice(ui->tmgridlines);
}
if (!caller || caller == ui->tinout) {
t->props.inout = GetOptionChoice(ui->tinout);
}
if (!caller || caller == ui->tlen) {
t->props.size = SpinChoiceGetValue(ui->tlen);
}
if (!caller || caller == ui->tpen) {
GetPenChoice(ui->tpen, &t->props.line.pen);
}
if (!caller || caller == ui->tgridlinew) {
t->props.line.width = SpinChoiceGetValue(ui->tlinew);
}
if (!caller || caller == ui->tgridlines) {
t->props.line.style = GetOptionChoice(ui->tlines);
}
if (!caller || caller == ui->tminout) {
t->mprops.inout = GetOptionChoice(ui->tminout);
}
if (!caller || caller == ui->tmlen) {
t->mprops.size = SpinChoiceGetValue(ui->tmlen);
}
if (!caller || caller == ui->tmpen) {
GetPenChoice(ui->tmpen, &t->mprops.line.pen);
}
if (!caller || caller == ui->tmgridlinew) {
t->mprops.line.width = SpinChoiceGetValue(ui->tmlinew);
}
if (!caller || caller == ui->tmgridlines) {
t->mprops.line.style = GetOptionChoice(ui->tmlines);
}
if (!caller ||
caller == ui->specticks || caller == ui->nspec || caller == ui->specloc) {
t->t_spec = GetOptionChoice(ui->specticks);
/* only read special info if special ticks used */
if (t->t_spec != TICKS_SPEC_NONE) {
t->nticks = (int) SpinChoiceGetValue(ui->nspec);
/* ensure that enough tick positions have been specified */
for (i = 0; i < t->nticks; i++) {
if (xv_evalexpr(ui->specloc[i], &t->tloc[i].wtpos) ==
RETURN_SUCCESS) {
char *cp, *s;
cp = TextGetString(ui->speclabel[i]);
if (cp[0] == '\0') {
t->tloc[i].type = TICK_TYPE_MINOR;
} else {
t->tloc[i].type = TICK_TYPE_MAJOR;
}
if (t->t_spec == TICKS_SPEC_BOTH) {
s = cp;
} else {
s = NULL;
}
t->tloc[i].label =
amem_strcpy(amem, t->tloc[i].label, s);
xfree(cp);
}
}
}
}
quark_dirtystate_set(q, TRUE);
return RETURN_SUCCESS;
} else {
return RETURN_FAILURE;
}
}
int set_project_data(ProjectUI *ui, Quark *q, void *caller)
{
Project *pr = project_get_data(q);
int retval = RETURN_SUCCESS;
if (ui && pr) {
GraceApp *gapp = gapp_from_quark(q);
double jul;
if (!caller || caller == ui->prec) {
project_set_prec(q, GetSpinChoice(ui->prec));
}
if (!caller || caller == ui->description) {
char *s = TextGetString(ui->description);
project_set_description(q, s);
xfree(s);
}
if (caller == ui->page_orient) {
int wpp, hpp;
int orientation = GetOptionChoice(ui->page_orient);
project_get_page_dimensions(q, &wpp, &hpp);
if ((orientation == PAGE_ORIENT_LANDSCAPE && wpp < hpp) ||
(orientation == PAGE_ORIENT_PORTRAIT && wpp > hpp)) {
set_page_dimensions(gapp, hpp, wpp, TRUE);
}
}
if (caller == ui->page_format) {
int wpp, hpp;
int orientation = GetOptionChoice(ui->page_orient);
int format = GetOptionChoice(ui->page_format);
GraceApp *gapp = gapp_from_quark(q);
switch (format) {
case PAGE_FORMAT_USLETTER:
wpp = 792.0;
hpp = 612.0;
break;
case PAGE_FORMAT_A4:
wpp = 842.0;
hpp = 595.0;
break;
default:
return RETURN_SUCCESS;
}
if (orientation == PAGE_ORIENT_PORTRAIT) {
iswap(&wpp, &hpp);
}
set_page_dimensions(gapp, wpp, hpp, TRUE);
}
if (!caller || caller == ui->page_x || caller == ui->page_y) {
int page_units = GetOptionChoice(ui->page_size_unit);
double factor, page_x, page_y;
GraceApp *gapp = gapp_from_quark(q);
if (xv_evalexpr(ui->page_x, &page_x) != RETURN_SUCCESS ||
xv_evalexpr(ui->page_y, &page_y) != RETURN_SUCCESS) {
errmsg("Invalid page dimension(s)");
return RETURN_FAILURE;
}
switch (page_units) {
case PAGE_UNITS_IN:
factor = 72.0;
break;
case PAGE_UNITS_CM:
factor = 72.0/CM_PER_INCH;
break;
default:
factor = 1.0;
break;
}
page_x *= factor;
page_y *= factor;
set_page_dimensions(gapp, (int) rint(page_x), (int) rint(page_y),
TRUE);
}
if (!caller || caller == ui->bg_color) {
pr->bgcolor = GetOptionChoice(ui->bg_color);
}
if (!caller || caller == ui->bg_fill) {
pr->bgfill = GetToggleButtonState(ui->bg_fill);
}
if (!caller || caller == ui->fsize_scale) {
pr->fscale = GetSpinChoice(ui->fsize_scale);
}
if (!caller || caller == ui->lwidth_scale) {
pr->lscale = GetSpinChoice(ui->lwidth_scale);
}
if (!caller || caller == ui->refdate) {
char *s = TextGetString(ui->refdate);
if (parse_date_or_number(q, s, TRUE,
get_date_hint(gapp), &jul) == RETURN_SUCCESS) {
pr->ref_date = jul;
} else {
errmsg("Invalid date");
retval = RETURN_FAILURE;
}
xfree(s);
}
if (!caller || caller == ui->two_digits_years) {
pr->two_digits_years = GetToggleButtonState(ui->two_digits_years);
}
if (!caller || caller == ui->wrap_year) {
char *s = TextGetString(ui->wrap_year);
pr->wrap_year = atoi(s);
xfree(s);
}
quark_dirtystate_set(q, TRUE);
}
return retval;
}
int graph_set_data(GraphUI *ui, Quark *q, void *caller)
{
if (quark_fid_get(q) == QFlavorGraph) {
double axislim, znorm;
world w;
GLocator *locator;
graph_get_world(q, &w);
locator = graph_get_locator(q);
if (!caller || caller == ui->graph_type) {
graph_set_type(q, GetOptionChoice(ui->graph_type));
}
if (!caller || caller == ui->stacked) {
graph_set_stacked(q, GetToggleButtonState(ui->stacked));
}
if (!caller || caller == ui->flip_xy) {
graph_set_xyflip(q, GetToggleButtonState(ui->flip_xy));
}
if (!caller || caller == ui->start_x) {
if (xv_evalexpr(ui->start_x, &axislim) != RETURN_SUCCESS) {
errmsg("Axis start/stop values undefined");
return RETURN_FAILURE;
}
w.xg1 = axislim;
}
if (!caller || caller == ui->stop_x) {
if (xv_evalexpr(ui->stop_x, &axislim) != RETURN_SUCCESS) {
errmsg("Axis start/stop values undefined");
return RETURN_FAILURE;
}
w.xg2 = axislim;
}
if (!caller || caller == ui->start_y) {
if (xv_evalexpr(ui->start_y, &axislim) != RETURN_SUCCESS) {
errmsg("Axis start/stop values undefined");
return RETURN_FAILURE;
}
w.yg1 = axislim;
}
if (!caller || caller == ui->stop_y) {
if (xv_evalexpr(ui->stop_y, &axislim) != RETURN_SUCCESS) {
errmsg("Axis start/stop values undefined");
return RETURN_FAILURE;
}
w.yg2 = axislim;
}
if (!caller ||
caller == ui->start_x || caller == ui->stop_x ||
caller == ui->start_y || caller == ui->stop_y) {
graph_set_world(q, &w);
}
if (!caller || caller == ui->scale_x) {
graph_set_xscale(q, GetOptionChoice(ui->scale_x));
}
if (!caller || caller == ui->invert_x) {
graph_set_xinvert(q, GetToggleButtonState(ui->invert_x));
}
if (!caller || caller == ui->scale_y) {
graph_set_yscale(q, GetOptionChoice(ui->scale_y));
}
if (!caller || caller == ui->invert_y) {
graph_set_yinvert(q, GetToggleButtonState(ui->invert_y));
}
if (!caller || caller == ui->bargap) {
graph_set_bargap(q, GetSpinChoice(ui->bargap));
}
if (!caller || caller == ui->znorm) {
xv_evalexpr(ui->znorm, &znorm);
graph_set_znorm(q, znorm);
}
if (!caller || caller == ui->loc_type) {
locator->type = GetOptionChoice(ui->loc_type);
quark_dirtystate_set(q, TRUE);
}
if (!caller || caller == ui->loc_fx) {
Format *format = GetFormatChoice(ui->loc_fx);
AMem *amem = quark_get_amem(q);
amem_free(amem, locator->fx.fstring);
locator->fx = *format;
locator->fx.fstring = amem_strdup(amem, format->fstring);
format_free(format);
quark_dirtystate_set(q, TRUE);
}
if (!caller || caller == ui->loc_fy) {
Format *format = GetFormatChoice(ui->loc_fy);
AMem *amem = quark_get_amem(q);
amem_free(amem, locator->fy.fstring);
locator->fy = *format;
locator->fy.fstring = amem_strdup(amem, format->fstring);
format_free(format);
quark_dirtystate_set(q, TRUE);
}
if (!caller || caller == ui->fixedp) {
locator->pointset = GetToggleButtonState(ui->fixedp);
quark_dirtystate_set(q, TRUE);
}
if (!caller || caller == ui->locx) {
xv_evalexpr(ui->locx, &locator->origin.x);
quark_dirtystate_set(q, TRUE);
}
if (!caller || caller == ui->locy) {
xv_evalexpr(ui->locy, &locator->origin.y);
quark_dirtystate_set(q, TRUE);
}
return RETURN_SUCCESS;
} else {
return RETURN_FAILURE;
}
}
