#ifndef lint

static char *RCSid() { return RCSid("$Id: save.c,v 1.331 2017-09-11 20:13:24 sfeam Exp $"); }

#include "save.h"

#include "command.h"

#include "contour.h"

#include "datafile.h"

#include "eval.h"

#include "fit.h"

#include "gp_time.h"

#include "graphics.h"

#include "hidden3d.h"

#include "jitter.h"

#include "misc.h"

#include "plot2d.h"

#include "plot3d.h"

#include "setshow.h"

#include "term_api.h"

#include "util.h"

#include "variable.h"

#include "pm3d.h"

#include "getcolor.h"

static void save_functions__sub __PROTO((FILE *));

static void save_variables__sub __PROTO((FILE *));

static void save_tics __PROTO((FILE *, struct axis *));

static void save_mtics __PROTO((FILE *, struct axis *));

static void save_zeroaxis __PROTO((FILE *,AXIS_INDEX));

static void save_set_all __PROTO((FILE *));

const char *coord_msg[] = {"first ", "second ", "graph ", "screen ", "character ", "polar "};

save_functions(FILE *fp)

{

/* I _love_ information written at the top and the end

show_version(fp);

save_functions__sub(fp);

fputs("# EOF\n", fp);

}

save_variables(FILE *fp)

{

show_version(fp);

save_variables__sub(fp);

fputs("# EOF\n", fp);

}

save_set(FILE *fp)

{

show_version(fp);

save_set_all(fp);

fputs("# EOF\n", fp);

}

save_all(FILE *fp)

{

show_version(fp);

save_set_all(fp);

save_functions__sub(fp);

save_variables__sub(fp);

if (df_filename)

fprintf(fp, "## Last datafile plotted: \"%s\"\n", df_filename);

fprintf(fp, "%s\n", replot_line);

if (wri_to_fil_last_fit_cmd(NULL)) {

fputs("## ", fp);

wri_to_fil_last_fit_cmd(fp);

putc('\n', fp);

}

fputs("# EOF\n", fp);

}

static void

save_functions__sub(FILE *fp)

{

struct udft_entry *udf = first_udf;

while (udf) {

if (udf->definition) {

fprintf(fp, "%s\n", udf->definition);

}

udf = udf->next_udf;

}

}

static void

save_variables__sub(FILE *fp)

{

/* always skip pi */

struct udvt_entry *udv = first_udv->next_udv;

while (udv) {

if (udv->udv_value.type != NOTDEFINED) {

if (udv->udv_value.type == ARRAY) {

fprintf(fp,"array %s[%d] = ", udv->udv_name,

udv->udv_value.v.value_array[0].v.int_val);

save_array_content(fp, udv->udv_value.v.value_array);

} else if (strncmp(udv->udv_name,"GPVAL_",6)

&& strncmp(udv->udv_name,"MOUSE_",6)

&& strncmp(udv->udv_name,"$",1)

&& (strncmp(udv->udv_name,"ARG",3) || (strlen(udv->udv_name) != 4))

&& strncmp(udv->udv_name,"NaN",4)) {

fprintf(fp, "%s = ", udv->udv_name);

disp_value(fp, &(udv->udv_value), TRUE);

(void) putc('\n', fp);

}

}

udv = udv->next_udv;

}

}

save_array_content(FILE *fp, struct value *array)

{

int i;

int size = array[0].v.int_val;

fprintf(fp, "[");

for (i=1; i<=size; i++) {

if (array[i].type != NOTDEFINED)

disp_value(fp, &(array[i]), TRUE);

if (i < size)

fprintf(fp, ",");

}

fprintf(fp, "]\n");

}

save_term(FILE *fp)

{

show_version(fp);

/* A possible gotcha: the default initialization often doesn't set

if (term)

fprintf(fp, "set terminal %s %s\n", term->name, term_options);

else

fputs("set terminal unknown\n", fp);

/* output will still be written in commented form. Otherwise, the

if (outstr)

fprintf(fp, "# set output '%s'\n", outstr);

else

fputs("# set output\n", fp);

fputs("# EOF\n", fp);

}

static void

save_justification(int just, FILE *fp)

{

switch (just) {

case RIGHT:

fputs(" right", fp);

break;

case LEFT:

fputs(" left", fp);

break;

case CENTRE:

fputs(" center", fp);

break;

}

}

static void

save_set_all(FILE *fp)

{

struct text_label *this_label;

struct arrow_def *this_arrow;

struct linestyle_def *this_linestyle;

struct arrowstyle_def *this_arrowstyle;

legend_key *key = &keyT;

int axis;

/* opinions are split as to whether we save term and outfile

if (term)

fprintf(fp, "# set terminal %s %s\n", term->name, term_options);

else

fputs("# set terminal unknown\n", fp);

if (outstr)

fprintf(fp, "# set output '%s'\n", outstr);

else

fputs("# set output\n", fp);

fprintf(fp, "\

%sset clip two\n",

(clip_points) ? "" : "un",

(clip_lines1) ? "" : "un",

(clip_lines2) ? "" : "un"

);

save_bars(fp);

if (draw_border) {

fprintf(fp, "set border %d %s", draw_border,

border_layer == LAYER_BEHIND ? "behind" : border_layer == LAYER_BACK ? "back" : "front");

save_linetype(fp, &border_lp, FALSE);

fprintf(fp, "\n");

} else

fputs("unset border\n", fp);

for (axis = 0; axis < NUMBER_OF_MAIN_VISIBLE_AXES; axis++) {

if (axis == SAMPLE_AXIS) continue;

if (axis == COLOR_AXIS) continue;

if (axis == POLAR_AXIS) continue;

fprintf(fp, "set %sdata %s\n", axis_name(axis),

axis_array[axis].datatype == DT_TIMEDATE ? "time" :

axis_array[axis].datatype == DT_DMS ? "geographic" :

"");

}

if (boxwidth < 0.0)

fputs("set boxwidth\n", fp);

else

fprintf(fp, "set boxwidth %g %s\n", boxwidth,

(boxwidth_is_absolute) ? "absolute" : "relative");

fprintf(fp, "set style fill ");

save_fillstyle(fp, &default_fillstyle);

#ifdef EAM_OBJECTS

/* Default rectangle style */

fprintf(fp, "set style rectangle %s fc ",

default_rectangle.layer > 0 ? "front" :

default_rectangle.layer < 0 ? "behind" : "back");

save_pm3dcolor(fp, &default_rectangle.lp_properties.pm3d_color);

fprintf(fp, " fillstyle ");

save_fillstyle(fp, &default_rectangle.fillstyle);

/* Default circle properties */

fprintf(fp, "set style circle radius ");

save_position(fp, &default_circle.o.circle.extent, 1, FALSE);

fputs(" \n", fp);

/* Default ellipse properties */

fprintf(fp, "set style ellipse size ");

save_position(fp, &default_ellipse.o.ellipse.extent, 2, FALSE);

fprintf(fp, " angle %g ", default_ellipse.o.ellipse.orientation);

fputs("units ", fp);

switch (default_ellipse.o.ellipse.type) {

case ELLIPSEAXES_XY:

fputs("xy\n", fp);

break;

case ELLIPSEAXES_XX:

fputs("xx\n", fp);

break;

case ELLIPSEAXES_YY:

fputs("yy\n", fp);

break;

}

if (dgrid3d) {

if (dgrid3d_mode == DGRID3D_QNORM) {

fprintf(fp, "set dgrid3d %d,%d, %d\n",

dgrid3d_row_fineness,

dgrid3d_col_fineness,

dgrid3d_norm_value);

} else if (dgrid3d_mode == DGRID3D_SPLINES) {

fprintf(fp, "set dgrid3d %d,%d splines\n",

dgrid3d_row_fineness, dgrid3d_col_fineness );

} else {

fprintf(fp, "set dgrid3d %d,%d %s%s %f,%f\n",

dgrid3d_row_fineness,

dgrid3d_col_fineness,

reverse_table_lookup(dgrid3d_mode_tbl, dgrid3d_mode),

dgrid3d_kdensity ? " kdensity2d" : "",

dgrid3d_x_scale,

dgrid3d_y_scale );

}

}

/* Dummy variable names */

fprintf(fp, "set dummy %s", set_dummy_var[0]);

for (axis=1; axis<MAX_NUM_VAR; axis++) {

if (*set_dummy_var[axis] == '\0')

break;

fprintf(fp, ", %s", set_dummy_var[axis]);

}

fprintf(fp, "\n");

save_axis_format(fp, FIRST_X_AXIS );

save_axis_format(fp, FIRST_Y_AXIS );

save_axis_format(fp, SECOND_X_AXIS);

save_axis_format(fp, SECOND_Y_AXIS);

save_axis_format(fp, FIRST_Z_AXIS );

save_axis_format(fp, COLOR_AXIS);

save_axis_format(fp, POLAR_AXIS);

fprintf(fp, "set ttics format \"%s\"\n", THETA_AXIS.formatstring);

fprintf(fp, "set timefmt \"%s\"\n", timefmt);

fprintf(fp, "set angles %s\n",

(ang2rad == 1.0) ? "radians" : "degrees");

fprintf(fp,"set tics %s\n", grid_tics_in_front ? "front" : "back");

if (! some_grid_selected())

fputs("unset grid\n", fp);

else {

if (polar_grid_angle) /* set angle already output */

fprintf(fp, "set grid polar %f\n", polar_grid_angle / ang2rad);

else

fputs("set grid nopolar\n", fp);

#define SAVE_GRID(axis) \

fprintf(fp, " %s%stics %sm%stics", \

axis_array[axis].gridmajor ? "" : "no", \

axis_name(axis), \

axis_array[axis].gridminor ? "" : "no", \

axis_name(axis));

fputs("set grid", fp);

SAVE_GRID(FIRST_X_AXIS);

SAVE_GRID(FIRST_Y_AXIS);

SAVE_GRID(FIRST_Z_AXIS);

SAVE_GRID(POLAR_AXIS);

fputs(" \\\n", fp);

SAVE_GRID(SECOND_X_AXIS);

SAVE_GRID(SECOND_Y_AXIS);

SAVE_GRID(COLOR_AXIS);

fputs("\n", fp);

#undef SAVE_GRID

fprintf(fp, "set grid %s ", (grid_layer==-1) ? "layerdefault" : ((grid_layer==0) ? "back" : "front"));

save_linetype(fp, &grid_lp, FALSE);

fprintf(fp, ", ");

save_linetype(fp, &mgrid_lp, FALSE);

fputc('\n', fp);

}

fprintf(fp, "%sset raxis\n", raxis ? "" : "un");

/* Theta axis origin and direction */

fprintf(fp, "set theta %s %s\n",

theta_direction > 0 ? "counterclockwise" : "clockwise",

theta_origin == 180 ? "left" : theta_origin == 90 ? "top" :

theta_origin == -90 ? "bottom" : "right");

/* Save parallel axis state */

save_style_parallel(fp);

fprintf(fp, "set key title \"%s\"", conv_text(key->title.text));

if (key->title.font)

fprintf(fp, " font \"%s\" ", key->title.font);

save_justification(key->title.pos, fp);

fputs("\n", fp);

fputs("set key ", fp);

switch (key->region) {

case GPKEY_AUTO_INTERIOR_LRTBC:

fputs(key->fixed ? "fixed" : "inside", fp);

break;

case GPKEY_AUTO_EXTERIOR_LRTBC:

fputs("outside", fp);

break;

case GPKEY_AUTO_EXTERIOR_MARGIN:

switch (key->margin) {

case GPKEY_TMARGIN:

fputs("tmargin", fp);

break;

case GPKEY_BMARGIN:

fputs("bmargin", fp);

break;

case GPKEY_LMARGIN:

fputs("lmargin", fp);

break;

case GPKEY_RMARGIN:

fputs("rmargin", fp);

break;

}

break;

case GPKEY_USER_PLACEMENT:

fputs("at ", fp);

save_position(fp, &key->user_pos, 2, FALSE);

break;

}

if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN

&& (key->margin == GPKEY_LMARGIN || key->margin == GPKEY_RMARGIN))) {

save_justification(key->hpos, fp);

}

if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN

&& (key->margin == GPKEY_TMARGIN || key->margin == GPKEY_BMARGIN))) {

switch (key->vpos) {

case JUST_TOP:

fputs(" top", fp);

break;

case JUST_BOT:

fputs(" bottom", fp);

break;

case JUST_CENTRE:

fputs(" center", fp);

break;

}

}

fprintf(fp, " %s %s %sreverse %senhanced %s ",

key->stack_dir == GPKEY_VERTICAL ? "vertical" : "horizontal",

key->just == GPKEY_LEFT ? "Left" : "Right",

key->reverse ? "" : "no",

key->enhanced ? "" : "no",

key->auto_titles == COLUMNHEAD_KEYTITLES ? "autotitle columnhead"

: key->auto_titles == FILENAME_KEYTITLES ? "autotitle"

: "noautotitle" );

if (key->box.l_type > LT_NODRAW) {

fputs("box", fp);

save_linetype(fp, &(key->box), FALSE);

} else

fputs("nobox", fp);

/* These are for the key entries, not the key title */

if (key->font)

fprintf(fp, " font \"%s\"", key->font);

if (key->textcolor.type != TC_LT || key->textcolor.lt != LT_BLACK)

save_textcolor(fp, &key->textcolor);

/* Put less common options on separate lines */

fprintf(fp, "\nset key %sinvert samplen %g spacing %g width %g height %g ",

key->invert ? "" : "no",

key->swidth, key->vert_factor, key->width_fix, key->height_fix);

fprintf(fp, "\nset key maxcolumns %d maxrows %d",key->maxcols,key->maxrows);

fputc('\n', fp);

fprintf(fp, "set key %sopaque\n", key->front ? "" : "no");

if (!(key->visible))

fputs("unset key\n", fp);

fputs("unset label\n", fp);

for (this_label = first_label; this_label != NULL;

this_label = this_label->next) {

fprintf(fp, "set label %d \"%s\" at ",

this_label->tag,

conv_text(this_label->text));

save_position(fp, &this_label->place, 3, FALSE);

if (this_label->hypertext)

fprintf(fp, " hypertext");

save_justification(this_label->pos, fp);

if (this_label->rotate)

fprintf(fp, " rotate by %d", this_label->rotate);

else

fprintf(fp, " norotate");

if (this_label->font != NULL)

fprintf(fp, " font \"%s\"", this_label->font);

fprintf(fp, " %s", (this_label->layer==0) ? "back" : "front");

if (this_label->noenhanced)

fprintf(fp, " noenhanced");

save_textcolor(fp, &(this_label->textcolor));

if ((this_label->lp_properties.flags & LP_SHOW_POINTS) == 0)

fprintf(fp, " nopoint");

else {

fprintf(fp, " point");

save_linetype(fp, &(this_label->lp_properties), TRUE);

}

save_position(fp, &this_label->offset, 3, TRUE);

#ifdef EAM_BOXED_TEXT

if (this_label->boxed)

fprintf(fp," boxed ");

fputc('\n', fp);

}

fputs("unset arrow\n", fp);

for (this_arrow = first_arrow; this_arrow != NULL;

this_arrow = this_arrow->next) {

fprintf(fp, "set arrow %d from ", this_arrow->tag);

save_position(fp, &this_arrow->start, 3, FALSE);

if (this_arrow->type == arrow_end_absolute) {

fputs(" to ", fp);

save_position(fp, &this_arrow->end, 3, FALSE);

} else if (this_arrow->type == arrow_end_absolute) {

fputs(" rto ", fp);

save_position(fp, &this_arrow->end, 3, FALSE);

} else { /* type arrow_end_oriented */

struct position *e = &this_arrow->end;

fputs(" length ", fp);

fprintf(fp, "%s%g", e->scalex == first_axes ? "" : coord_msg[e->scalex], e->x);

fprintf(fp, " angle %g", this_arrow->angle);

}

fprintf(fp, " %s %s %s",

arrow_head_names[this_arrow->arrow_properties.head],

(this_arrow->arrow_properties.layer==0) ? "back" : "front",

(this_arrow->arrow_properties.headfill==AS_FILLED) ? "filled" :

(this_arrow->arrow_properties.headfill==AS_EMPTY) ? "empty" :

(this_arrow->arrow_properties.headfill==AS_NOBORDER) ? "noborder" :

"nofilled");

save_linetype(fp, &(this_arrow->arrow_properties.lp_properties), FALSE);

if (this_arrow->arrow_properties.head_length > 0) {

fprintf(fp, " size %s %.3f,%.3f,%.3f",

coord_msg[this_arrow->arrow_properties.head_lengthunit],

this_arrow->arrow_properties.head_length,

this_arrow->arrow_properties.head_angle,

this_arrow->arrow_properties.head_backangle);

}

fprintf(fp, "\n");

}

#if TRUE || defined(BACKWARDS_COMPATIBLE)

fprintf(fp, "set style increment %s\n", prefer_line_styles ? "userstyles" : "default");

fputs("unset style line\n", fp);

for (this_linestyle = first_linestyle; this_linestyle != NULL;

this_linestyle = this_linestyle->next) {

fprintf(fp, "set style line %d ", this_linestyle->tag);

save_linetype(fp, &(this_linestyle->lp_properties), TRUE);

fprintf(fp, "\n");

}

/* TODO save "set linetype" as well, or instead */

fputs("unset style arrow\n", fp);

for (this_arrowstyle = first_arrowstyle; this_arrowstyle != NULL;

this_arrowstyle = this_arrowstyle->next) {

fprintf(fp, "set style arrow %d", this_arrowstyle->tag);

fprintf(fp, " %s %s %s",

arrow_head_names[this_arrowstyle->arrow_properties.head],

(this_arrowstyle->arrow_properties.layer==0)?"back":"front",

(this_arrowstyle->arrow_properties.headfill==AS_FILLED)?"filled":

(this_arrowstyle->arrow_properties.headfill==AS_EMPTY)?"empty":

(this_arrowstyle->arrow_properties.headfill==AS_NOBORDER)?"noborder":

"nofilled");

save_linetype(fp, &(this_arrowstyle->arrow_properties.lp_properties), FALSE);

if (this_arrowstyle->arrow_properties.head_length > 0) {

fprintf(fp, " size %s %.3f,%.3f,%.3f",

coord_msg[this_arrowstyle->arrow_properties.head_lengthunit],

this_arrowstyle->arrow_properties.head_length,

this_arrowstyle->arrow_properties.head_angle,

this_arrowstyle->arrow_properties.head_backangle);

if (this_arrowstyle->arrow_properties.head_fixedsize) {

fputs(" ", fp);

fputs(" fixed", fp);

}

}

fprintf(fp, "\n");

}

fprintf(fp, "set style histogram ");

save_histogram_opts(fp);

#ifdef EAM_OBJECTS

fprintf(fp, "unset object\n");

save_object(fp, 0);

#ifdef EAM_BOXED_TEXT

fprintf(fp, "set style textbox");

save_style_textbox(fp);

save_offsets(fp, "set offsets");

/* FIXME */

fprintf(fp, "\

%sset parametric\n",

pointsize, pointintervalbox,

encoding_names[encoding],

(polar) ? "" : "un",

(parametric) ? "" : "un");

if (numeric_locale)

fprintf(fp, "set decimalsign locale \"%s\"\n", numeric_locale);

if (decimalsign != NULL)

fprintf(fp, "set decimalsign '%s'\n", decimalsign);

if (!numeric_locale && !decimalsign)

fprintf(fp, "unset decimalsign\n");

fprintf(fp, "%sset micro\n", use_micro ? "" : "un");

fprintf(fp, "%sset minussign\n", use_minus_sign ? "" : "un");

fputs("set view ", fp);

if (splot_map == TRUE)

fprintf(fp, "map scale %g", mapview_scale);

else {

fprintf(fp, "%g, %g, %g, %g",

surface_rot_x, surface_rot_z, surface_scale, surface_zscale);

fprintf(fp, "\nset view azimuth %g", azimuth);

}

if (aspect_ratio_3D)

fprintf(fp, "\nset view %s", aspect_ratio_3D == 2 ? "equal xy" :

aspect_ratio_3D == 3 ? "equal xyz": "");

fprintf(fp, "\nset rgbmax %g", rgbmax);

fprintf(fp, "\n\

%sset surface %s",

samples_1, samples_2,

iso_samples_1, iso_samples_2,

(draw_surface) ? "" : "un",

(implicit_surface) ? "" : "explicit");

fprintf(fp, "\n\

%sset contour", (draw_contour) ? "" : "un");

switch (draw_contour) {

case CONTOUR_NONE:

fputc('\n', fp);

break;

case CONTOUR_BASE:

fputs(" base\n", fp);

break;

case CONTOUR_SRF:

fputs(" surface\n", fp);

break;

case CONTOUR_BOTH:

fputs(" both\n", fp);

break;

}

/* Contour label options */

fprintf(fp, "set cntrlabel %s format '%s' font '%s' start %d interval %d\n",

clabel_onecolor ? "onecolor" : "", contour_format,

clabel_font ? clabel_font : "",

clabel_start, clabel_interval);

fputs("set mapping ", fp);

switch (mapping3d) {

case MAP3D_SPHERICAL:

fputs("spherical\n", fp);

break;

case MAP3D_CYLINDRICAL:

fputs("cylindrical\n", fp);

break;

case MAP3D_CARTESIAN:

default:

fputs("cartesian\n", fp);

break;

}

if (missing_val != NULL)

fprintf(fp, "set datafile missing '%s'\n", missing_val);

if (df_separators)

fprintf(fp, "set datafile separator \"%s\"\n",df_separators);

else

fprintf(fp, "set datafile separator whitespace\n");

if (strcmp(df_commentschars, DEFAULT_COMMENTS_CHARS))

fprintf(fp, "set datafile commentschars '%s'\n", df_commentschars);

if (df_fortran_constants)

fprintf(fp, "set datafile fortran\n");

if (df_nofpe_trap)

fprintf(fp, "set datafile nofpe_trap\n");

save_hidden3doptions(fp);

fprintf(fp, "set cntrparam order %d\n", contour_order);

fputs("set cntrparam ", fp);

switch (contour_kind) {

case CONTOUR_KIND_LINEAR:

fputs("linear\n", fp);

break;

case CONTOUR_KIND_CUBIC_SPL:

fputs("cubicspline\n", fp);

break;

case CONTOUR_KIND_BSPLINE:

fputs("bspline\n", fp);

break;

}

fputs("set cntrparam levels ", fp);

switch (contour_levels_kind) {

case LEVELS_AUTO:

fprintf(fp, "auto %d\n", contour_levels);

break;

case LEVELS_INCREMENTAL:

fprintf(fp, "incremental %g,%g,%g\n",

contour_levels_list[0], contour_levels_list[1],

contour_levels_list[0] + contour_levels_list[1] * contour_levels);

break;

case LEVELS_DISCRETE:

{

int i;

fprintf(fp, "discrete %g", contour_levels_list[0]);

for (i = 1; i < contour_levels; i++)

fprintf(fp, ",%g ", contour_levels_list[i]);

fputc('\n', fp);

}

}

fprintf(fp, "\

set origin %g,%g\n",

contour_pts,

aspect_ratio, xsize, ysize,

xoffset, yoffset);

fprintf(fp, "set style data ");

save_data_func_style(fp,"data",data_style);

fprintf(fp, "set style function ");

save_data_func_style(fp,"function",func_style);

save_zeroaxis(fp, FIRST_X_AXIS);

save_zeroaxis(fp, FIRST_Y_AXIS);

save_zeroaxis(fp, FIRST_Z_AXIS);

save_zeroaxis(fp, SECOND_X_AXIS);

save_zeroaxis(fp, SECOND_Y_AXIS);

if (xyplane.absolute)

fprintf(fp, "set xyplane at %g\n", xyplane.z);

else

fprintf(fp, "set xyplane relative %g\n", xyplane.z);

{

int i;

fprintf(fp, "set tics scale ");

for (i=0; i<MAX_TICLEVEL; i++)

fprintf(fp, " %g%c", ticscale[i], i<MAX_TICLEVEL-1 ? ',' : '\n');

}

save_mtics(fp, &axis_array[FIRST_X_AXIS]);

save_mtics(fp, &axis_array[FIRST_Y_AXIS]);

save_mtics(fp, &axis_array[FIRST_Z_AXIS]);

save_mtics(fp, &axis_array[SECOND_X_AXIS]);

save_mtics(fp, &axis_array[SECOND_Y_AXIS]);

save_mtics(fp, &axis_array[COLOR_AXIS]);

save_mtics(fp, &R_AXIS);

save_mtics(fp, &THETA_AXIS);

save_tics(fp, &axis_array[FIRST_X_AXIS]);

save_tics(fp, &axis_array[FIRST_Y_AXIS]);

save_tics(fp, &axis_array[FIRST_Z_AXIS]);

save_tics(fp, &axis_array[SECOND_X_AXIS]);

save_tics(fp, &axis_array[SECOND_Y_AXIS]);

save_tics(fp, &axis_array[COLOR_AXIS]);

save_tics(fp, &R_AXIS);

save_tics(fp, &THETA_AXIS);

for (axis=0; axis<num_parallel_axes; axis++)

save_tics(fp, &parallel_axis[axis]);

#define SAVE_AXISLABEL_OR_TITLE(name,suffix,lab) \

{ \

fprintf(fp, "set %s%s \"%s\" ", \

name, suffix, lab.text ? conv_text(lab.text) : ""); \

fprintf(fp, "\nset %s%s ", name, suffix); \

save_position(fp, &(lab.offset), 3, TRUE); \

fprintf(fp, " font \"%s\"", lab.font ? conv_text(lab.font) : "");\

save_textcolor(fp, &(lab.textcolor)); \

if (lab.tag == ROTATE_IN_3D_LABEL_TAG) \

fprintf(fp, " rotate parallel"); \

else if (lab.rotate == TEXT_VERTICAL) \

fprintf(fp, " rotate"); \

else if (lab.rotate) \

fprintf(fp, " rotate by %d", lab.rotate); \

else \

fprintf(fp, " norotate"); \

fprintf(fp, "%s\n", (lab.noenhanced) ? " noenhanced" : ""); \

}

SAVE_AXISLABEL_OR_TITLE("", "title", title);

fprintf(fp, "set timestamp %s \n", timelabel_bottom ? "bottom" : "top");

SAVE_AXISLABEL_OR_TITLE("", "timestamp", timelabel);

save_prange(fp, axis_array + T_AXIS);

save_prange(fp, axis_array + U_AXIS);

save_prange(fp, axis_array + V_AXIS);

#define SAVE_AXISLABEL(axis) \

SAVE_AXISLABEL_OR_TITLE(axis_name(axis),"label", \

axis_array[axis].label)

SAVE_AXISLABEL(FIRST_X_AXIS);

SAVE_AXISLABEL(SECOND_X_AXIS);

save_prange(fp, axis_array + FIRST_X_AXIS);

save_prange(fp, axis_array + SECOND_X_AXIS);

SAVE_AXISLABEL(FIRST_Y_AXIS);

SAVE_AXISLABEL(SECOND_Y_AXIS);

save_prange(fp, axis_array + FIRST_Y_AXIS);

save_prange(fp, axis_array + SECOND_Y_AXIS);

SAVE_AXISLABEL(FIRST_Z_AXIS);

save_prange(fp, axis_array + FIRST_Z_AXIS);

SAVE_AXISLABEL(COLOR_AXIS);

save_prange(fp, axis_array + COLOR_AXIS);

SAVE_AXISLABEL(POLAR_AXIS);

save_prange(fp, axis_array + POLAR_AXIS);

for (axis=0; axis<num_parallel_axes; axis++)

save_prange(fp, &parallel_axis[axis]);

#undef SAVE_AXISLABEL

#undef SAVE_AXISLABEL_OR_TITLE

fputs("unset logscale\n", fp);

for (axis = 0; axis < NUMBER_OF_MAIN_VISIBLE_AXES; axis++) {

if (axis_array[axis].log)

fprintf(fp, "set logscale %s %g\n", axis_name(axis),

axis_array[axis].base);

else

save_nonlinear(fp, &axis_array[axis]);

}

/* These will only print something if the axis is, in fact, linked */

save_link(fp, axis_array + SECOND_X_AXIS);

save_link(fp, axis_array + SECOND_Y_AXIS);

save_jitter(fp);

fprintf(fp, "set zero %g\n", zero);

fprintf(fp, "set lmargin %s %g\n",

lmargin.scalex == screen ? "at screen" : "", lmargin.x);

fprintf(fp, "set bmargin %s %g\n",

bmargin.scalex == screen ? "at screen" : "", bmargin.x);

fprintf(fp, "set rmargin %s %g\n",

rmargin.scalex == screen ? "at screen" : "", rmargin.x);

fprintf(fp, "set tmargin %s %g\n",

tmargin.scalex == screen ? "at screen" : "", tmargin.x);

fprintf(fp, "set locale \"%s\"\n", get_time_locale());

/* pm3d options */

fputs("set pm3d ", fp);

fputs((PM3D_IMPLICIT == pm3d.implicit ? "implicit" : "explicit"), fp);

fprintf(fp, " at %s\n", pm3d.where);

fputs("set pm3d ", fp);

switch (pm3d.direction) {

case PM3D_SCANS_AUTOMATIC: fputs("scansautomatic\n", fp); break;

case PM3D_SCANS_FORWARD: fputs("scansforward\n", fp); break;

case PM3D_SCANS_BACKWARD: fputs("scansbackward\n", fp); break;

case PM3D_DEPTH: fputs("depthorder\n", fp); break;

}

fprintf(fp, "set pm3d interpolate %d,%d", pm3d.interp_i, pm3d.interp_j);

fputs(" flush ", fp);

switch (pm3d.flush) {

case PM3D_FLUSH_CENTER: fputs("center", fp); break;

case PM3D_FLUSH_BEGIN: fputs("begin", fp); break;

case PM3D_FLUSH_END: fputs("end", fp); break;

}

fputs((pm3d.ftriangles ? " " : " no"), fp);

fputs("ftriangles", fp);

if (pm3d.border.l_type == LT_NODRAW) {

fprintf(fp," noborder");

} else {

fprintf(fp," border");

save_linetype(fp, &(pm3d.border), FALSE);

}

fputs(" corners2color ", fp);

switch (pm3d.which_corner_color) {

case PM3D_WHICHCORNER_MEAN: fputs("mean", fp); break;

case PM3D_WHICHCORNER_GEOMEAN: fputs("geomean", fp); break;

case PM3D_WHICHCORNER_HARMEAN: fputs("harmean", fp); break;

case PM3D_WHICHCORNER_MEDIAN: fputs("median", fp); break;

case PM3D_WHICHCORNER_MIN: fputs("min", fp); break;

case PM3D_WHICHCORNER_MAX: fputs("max", fp); break;

case PM3D_WHICHCORNER_RMS: fputs("rms", fp); break;

default: /* PM3D_WHICHCORNER_C1 ... _C4 */

fprintf(fp, "c%i", pm3d.which_corner_color - PM3D_WHICHCORNER_C1 + 1);

}

fputs("\n", fp);

if (pm3d_shade.strength <= 0)

fputs("set pm3d nolighting\n",fp);

else

fprintf(fp, "set pm3d lighting primary %g specular %g\n", pm3d_shade.strength, pm3d_shade.spec);

/*

fprintf( fp, "set palette %s %s maxcolors %d ",

sm_palette.positive==SMPAL_POSITIVE ? "positive" : "negative",

sm_palette.ps_allcF ? "ps_allcF" : "nops_allcF",

sm_palette.use_maxcolors);

fprintf( fp, "gamma %g ", sm_palette.gamma );

if (sm_palette.colorMode == SMPAL_COLOR_MODE_GRAY) {

fputs( "gray\n", fp );

}

else {

fputs( "color model ", fp );

switch( sm_palette.cmodel ) {

default:

case C_MODEL_RGB: fputs( "RGB ", fp ); break;

case C_MODEL_HSV: fputs( "HSV ", fp ); break;

case C_MODEL_CMY: fputs( "CMY ", fp ); break;

case C_MODEL_YIQ: fputs( "YIQ ", fp ); break;

case C_MODEL_XYZ: fputs( "XYZ ", fp ); break;

}

fputs( "\nset palette ", fp );

switch( sm_palette.colorMode ) {

default:

case SMPAL_COLOR_MODE_RGB:

fprintf( fp, "rgbformulae %d, %d, %d\n", sm_palette.formulaR,

sm_palette.formulaG, sm_palette.formulaB );

break;

case SMPAL_COLOR_MODE_GRADIENT: {

int i=0;

fprintf( fp, "defined (" );

for (i=0; i<sm_palette.gradient_num; i++) {

fprintf( fp, " %.4g %.4g %.4g %.4g", sm_palette.gradient[i].pos,

sm_palette.gradient[i].col.r, sm_palette.gradient[i].col.g,

sm_palette.gradient[i].col.b );

if (i<sm_palette.gradient_num-1) {

fputs( ",", fp);

if (i==2 || i%4==2) fputs( "\\\n ", fp );

}

}

fputs( " )\n", fp );

break;

}

case SMPAL_COLOR_MODE_FUNCTIONS:

fprintf( fp, "functions %s, %s, %s\n", sm_palette.Afunc.definition,

sm_palette.Bfunc.definition, sm_palette.Cfunc.definition );

break;

case SMPAL_COLOR_MODE_CUBEHELIX:

fprintf( fp, "cubehelix start %.2g cycles %.2g saturation %.2g\n",

sm_palette.cubehelix_start, sm_palette.cubehelix_cycles,

sm_palette.cubehelix_saturation);

break;

}

}

/*

if (color_box.where != SMCOLOR_BOX_NO)

fprintf(fp,"set colorbox %s\n", color_box.where==SMCOLOR_BOX_DEFAULT ? "default" : "user");

fprintf(fp, "set colorbox %sal origin ", color_box.rotation == 'v' ? "vertic" : "horizont");

save_position(fp, &color_box.origin, 2, FALSE);

fputs(" size ", fp);

save_position(fp, &color_box.size, 2, FALSE);

fprintf(fp, " %s ", color_box.layer == LAYER_FRONT ? "front" : "back");

fprintf(fp, " %sinvert ", color_box.invert ? "" : "no");

if (color_box.border == 0) fputs("noborder", fp);

else if (color_box.border_lt_tag < 0) fputs("bdefault", fp);

else fprintf(fp, "border %d", color_box.border_lt_tag);

if (color_box.where == SMCOLOR_BOX_NO) fputs("\nunset colorbox\n", fp);

else fputs("\n", fp);

fprintf(fp, "set style boxplot %s %s %5.2f %soutliers pt %d separation %g labels %s %ssorted\n",

boxplot_opts.plotstyle == FINANCEBARS ? "financebars" : "candles",

boxplot_opts.limit_type == 1 ? "fraction" : "range",

boxplot_opts.limit_value,

boxplot_opts.outliers ? "" : "no",

boxplot_opts.pointtype+1,

boxplot_opts.separation,

(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_X) ? "x" :

(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_X2) ? "x2" :

(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_AUTO) ? "auto" :"off",

boxplot_opts.sort_factors ? "" : "un");

fputs("set loadpath ", fp);

{

char *s;

while ((s = save_loadpath()) != NULL)