#include "driver.h"

#ifdef TERM_REGISTER

register_term(canvas_driver)

#ifdef TERM_PROTO

TERM_PUBLIC void CANVAS_options(void);

TERM_PUBLIC void CANVAS_init(void);

TERM_PUBLIC void CANVAS_graphics(void);

TERM_PUBLIC int CANVAS_justify_text(enum JUSTIFY mode);

TERM_PUBLIC void CANVAS_text(void);

TERM_PUBLIC void CANVAS_reset(void);

TERM_PUBLIC void CANVAS_linetype(int linetype);

TERM_PUBLIC void CANVAS_dashtype(int type, t_dashtype *custom_dash_type);

TERM_PUBLIC void CANVAS_fillbox(int style, unsigned int x1, unsigned int y1,

unsigned int width, unsigned int height);

TERM_PUBLIC void CANVAS_linewidth(double linewidth);

TERM_PUBLIC void CANVAS_move(unsigned int x, unsigned int y);

TERM_PUBLIC void CANVAS_vector(unsigned int x, unsigned int y);

TERM_PUBLIC void CANVAS_point(unsigned int x, unsigned int y, int number);

TERM_PUBLIC void CANVAS_pointsize(double size);

TERM_PUBLIC void CANVAS_put_text(unsigned int x, unsigned int y, const char *str);

TERM_PUBLIC int CANVAS_text_angle(float ang);

TERM_PUBLIC void CANVAS_filled_polygon(int, gpiPoint *);

TERM_PUBLIC void CANVAS_set_color(t_colorspec *colorspec);

TERM_PUBLIC int CANVAS_make_palette(t_sm_palette *palette);

TERM_PUBLIC void CANVAS_layer(t_termlayer);

TERM_PUBLIC void CANVAS_path(int);

TERM_PUBLIC void CANVAS_hypertext(int, const char *);

TERM_PUBLIC int CANVAS_set_font(const char *);

TERM_PUBLIC void ENHCANVAS_OPEN(char *, double, double, TBOOLEAN, TBOOLEAN, int);

TERM_PUBLIC void ENHCANVAS_FLUSH(void);

TERM_PUBLIC void ENHCANVAS_put_text(unsigned int, unsigned int, const char *);

#define CANVAS_OVERSAMPLE 10.

#define CANVAS_XMAX (600 * CANVAS_OVERSAMPLE)

#define CANVAS_YMAX (400 * CANVAS_OVERSAMPLE)

#define CANVASVTIC (10 * CANVAS_OVERSAMPLE)

#define CANVASHTIC (10 * CANVAS_OVERSAMPLE)

#define CANVASVCHAR (10 * CANVAS_OVERSAMPLE)

#define CANVASHCHAR (8 * CANVAS_OVERSAMPLE)

#endif /* TERM_PROTO */

#ifdef TERM_BODY

#define CANVAS_AXIS_CONST '\1'

#define CANVAS_BORDER_CONST '\2'

static int canvas_x = -1; /* current X position */

static int canvas_y = -1; /* current Y position */

static int canvas_xmax = CANVAS_XMAX;

static int canvas_ymax = CANVAS_YMAX;

static int canvas_line_type = LT_UNDEFINED;

static int canvas_dash_type = DASHTYPE_SOLID;

static double canvas_linewidth = 1.0;

static double canvas_dashlength_factor = 1.0;

static double CANVAS_ps = 1; /* pointsize multiplier */

static double CANVAS_default_fsize = 10;

static double canvas_font_size = 10;

static double canvas_fontscale = 1.0;

static char * canvas_font_name = NULL;

static char *canvas_justify = "";

static int canvas_text_angle = 0;

static int canvas_in_a_path = FALSE;

static int already_closed = FALSE;

static TBOOLEAN canvas_dashed = TRUE; /* Version 5: dashes always enabled */

static t_linecap canvas_linecap = ROUNDED;

static TBOOLEAN CANVAS_mouseable = FALSE;

static TBOOLEAN CANVAS_standalone = TRUE;

static char CANVAS_background[18] = {'\0'};

static char *CANVAS_name = NULL;

static char *CANVAS_scriptdir = NULL;

static char *CANVAS_title = NULL;

static char *CANVAS_hypertext_text = NULL;

static int CANVAS_imageno = 0;

typedef struct canvas_imagefile {

} canvas_imagefile;

static canvas_imagefile *imagelist = NULL;

static struct {

int previous_linewidth;

double alpha; /* alpha channel */

char color[24]; /* rgba(rrr,ggg,bbb,aaaa) */

char previous_color[24]; /* rgba(rrr,ggg,bbb,aaaa) */

char previous_fill[24]; /* rgba(rrr,ggg,bbb,aaaa) */

int plotno; /* Which plot are we in? */

} canvas_state;

enum CANVAS_case {

};

static struct gen_table CANVAS_opts[] =

{

{ "font", CANVAS_FONT },

{ "fsize", CANVAS_FSIZE },

{ "name", CANVAS_NAME },

{ "size", CANVAS_SIZE },

{ "standalone", CANVAS_STANDALONE },

{ "mous$ing", CANVAS_MOUSING },

{ "mouse", CANVAS_MOUSING },

{ "js$dir", CANVAS_JSDIR },

{ "enh$anced", CANVAS_ENH },

{ "noenh$anced", CANVAS_NOENH },

{ "lw", CANVAS_LINEWIDTH },

{ "linew$idth", CANVAS_LINEWIDTH },

{ "title", CANVAS_TITLE },

{ "fontscale", CANVAS_FONTSCALE },

{ "solid", CANVAS_SOLID },

{ "dash$ed", CANVAS_DASHED },

{ "dashl$ength", CANVAS_DASHLENGTH },

{ "dl", CANVAS_DASHLENGTH },

{ "round$ed", CANVAS_ROUNDED },

{ "butt", CANVAS_BUTT },

{ "square", CANVAS_SQUARE },

{ "backg$round", CANVAS_BACKGROUND },

{ NULL, CANVAS_OTHER }

};

#define PATTERN1 "tile.moveTo(0,0); tile.lineTo(32,32); tile.moveTo(0,16); tile.lineTo(16,32); tile.moveTo(16,0); tile.lineTo(32,16);"

#define PATTERN2 "tile.moveTo(0,32); tile.lineTo(32,0); tile.moveTo(0,16); tile.lineTo(16,0); tile.moveTo(16,32); tile.lineTo(32,16);"

#define PATTERN3 "tile.moveTo(8,0); tile.lineTo(32,24); tile.moveTo(0,8); tile.lineTo(24,32); tile.moveTo(24,0); tile.lineTo(32,8); tile.moveTo(0,24); tile.lineTo(8,32); tile.moveTo(8,32); tile.lineTo(32,8); tile.moveTo(0,24); tile.lineTo(24,0); tile.moveTo(24,32); tile.lineTo(32,24); tile.moveTo(0,8); tile.lineTo(8,0);"

static void

CANVAS_start (void)

{

if (canvas_in_a_path)

return;

fprintf(gpoutfile, "ctx.beginPath();\n");

canvas_in_a_path = TRUE;

already_closed = FALSE;

}

static void

CANVAS_finish (void)

{

if (!canvas_in_a_path)

return;

fprintf(gpoutfile, "ctx.stroke();\n");

if (!already_closed)

fprintf(gpoutfile, "ctx.closePath();\n");

canvas_in_a_path = FALSE;

already_closed = TRUE;

}

TERM_PUBLIC void

CANVAS_options()

{

int canvas_background = 0;

if (!almost_equals(c_token-1, "termopt$ion")) {

/* Re-initialize a few things */

canvas_font_size = CANVAS_default_fsize = 10;

canvas_fontscale = 1.0;

CANVAS_standalone = TRUE;

CANVAS_mouseable = FALSE;

free(CANVAS_name);

CANVAS_name = NULL;

free(CANVAS_title);

CANVAS_title = NULL;

free(CANVAS_scriptdir);

CANVAS_scriptdir = NULL;

canvas_linewidth = 1.0;

canvas_dashed = TRUE;

canvas_dashlength_factor = 1.0;

CANVAS_background[0] = '\0';

/* Default to enhanced text mode */

term->put_text = ENHCANVAS_put_text;

term->flags |= TERM_ENHANCED_TEXT;

}

while (!END_OF_COMMAND) {

switch(lookup_table(&CANVAS_opts[0],c_token++)) {

case CANVAS_SIZE:

if (END_OF_COMMAND) {

canvas_xmax = CANVAS_XMAX;

canvas_ymax = CANVAS_YMAX;

} else {

canvas_xmax = int_expression() * CANVAS_OVERSAMPLE;

if (equals(c_token,",")) {

c_token++;

canvas_ymax = int_expression() * CANVAS_OVERSAMPLE;

}

}

if (canvas_xmax <= 0)

canvas_xmax = CANVAS_XMAX;

if (canvas_ymax <= 0)

canvas_ymax = CANVAS_YMAX;

term->xmax = canvas_xmax;

term->ymax = canvas_ymax;

break;

case CANVAS_TITLE:

CANVAS_title = try_to_get_string();

if (!CANVAS_title)

int_error(c_token,"expecting an HTML title string");

break;

case CANVAS_NAME:

CANVAS_name = try_to_get_string();

if (!CANVAS_name)

int_error(c_token,"expecting a javascript function name");

if (CANVAS_name[strspn(CANVAS_name,

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_1234567890")])

int_error(c_token-1,"illegal javascript function name");

CANVAS_standalone = FALSE;

break;

case CANVAS_STANDALONE:

CANVAS_standalone = TRUE;

break;

case CANVAS_FONT:

/* FIXME: See note at CANVAS_set_font() */

free(canvas_font_name);

if (!(canvas_font_name = try_to_get_string()))

int_error(c_token,"font: expecting string");

CANVAS_set_font(canvas_font_name);

break;

case CANVAS_FSIZE:

CANVAS_default_fsize = real_expression();

if (CANVAS_default_fsize <= 0)

CANVAS_default_fsize = 10;

canvas_font_size = CANVAS_default_fsize;

break;

case CANVAS_MOUSING:

CANVAS_mouseable = TRUE;

break;

case CANVAS_JSDIR:

CANVAS_scriptdir = try_to_get_string();

break;

case CANVAS_ENH:

term->put_text = ENHCANVAS_put_text;

term->flags |= TERM_ENHANCED_TEXT;

break;

case CANVAS_NOENH:

term->put_text = CANVAS_put_text;

term->flags &= ~TERM_ENHANCED_TEXT;

break;

case CANVAS_LINEWIDTH:

canvas_linewidth = real_expression();

if (canvas_linewidth <= 0)

canvas_linewidth = 1.0;

break;

case CANVAS_FONTSCALE:

canvas_fontscale = real_expression();

if (canvas_fontscale <= 0)

canvas_fontscale = 1.0;

break;

case CANVAS_SOLID:

case CANVAS_DASHED:

/* Version 5 always allows dashes */

canvas_dashed = TRUE;

break;

case CANVAS_DASHLENGTH:

canvas_dashlength_factor = real_expression();

if (canvas_dashlength_factor <= 0.2)

canvas_dashlength_factor = 1.0;

break;

case CANVAS_ROUNDED:

canvas_linecap = ROUNDED;

break;

case CANVAS_BUTT:

canvas_linecap = BUTT;

break;

case CANVAS_SQUARE:

canvas_linecap = SQUARE;

break;

case CANVAS_BACKGROUND:

canvas_background = parse_color_name();

sprintf(CANVAS_background," rgb(%03d,%03d,%03d)",

(canvas_background >> 16) & 0xff,

(canvas_background >> 8) & 0xff,

canvas_background & 0xff);

break;

default:

int_warn(c_token-1,"unrecognized terminal option");

break;

}

}

term->v_char = canvas_font_size * canvas_fontscale * CANVAS_OVERSAMPLE;

term->h_char = canvas_font_size * canvas_fontscale * 0.8 * CANVAS_OVERSAMPLE;

if (canvas_dashlength_factor != 1.0)

sprintf(term_options + strlen(term_options), " dashlength %3.1f", canvas_dashlength_factor);

sprintf(term_options + strlen(term_options),

canvas_linecap == ROUNDED ? " rounded" :

canvas_linecap == SQUARE ? " square" : " butt");

sprintf(term_options + strlen(term_options), " size %d,%d", (int)(term->xmax/CANVAS_OVERSAMPLE), (int)(term->ymax/CANVAS_OVERSAMPLE));

sprintf(term_options + strlen(term_options), "%s fsize %g lw %g",

term->put_text == ENHCANVAS_put_text ? " enhanced" : "",

canvas_font_size, canvas_linewidth);

sprintf(term_options + strlen(term_options), " fontscale %g", canvas_fontscale);

if (*CANVAS_background)

sprintf(term_options + strlen(term_options), " background \"#%06x\"", canvas_background);

if (CANVAS_name)

sprintf(term_options + strlen(term_options), " name \"%s\"", CANVAS_name);

else {

sprintf(term_options + strlen(term_options), " standalone");

if (CANVAS_mouseable)

sprintf(term_options + strlen(term_options), " mousing");

if (CANVAS_title)

sprintf(term_options + strlen(term_options), " title \"%s\"", CANVAS_title);

}

if (CANVAS_scriptdir)

sprintf(term_options + strlen(term_options), " jsdir \"%s\"", CANVAS_scriptdir);

}

TERM_PUBLIC void

CANVAS_init()

{

}

TERM_PUBLIC void

CANVAS_graphics()

{

int len;

/* Force initialization at the beginning of each plot */

canvas_line_type = LT_UNDEFINED;

canvas_text_angle = 0;

canvas_in_a_path = FALSE;

canvas_state.previous_linewidth = -1;

canvas_state.previous_color[0] = '\0';

canvas_state.previous_fill[0] = '\0';

strcpy(canvas_state.color,"rgba(000,000,000,0.00)");

canvas_state.plotno = 0;

/*

if (CANVAS_scriptdir == NULL) {

#ifdef GNUPLOT_JS_DIR

# if defined(_WIN32) || defined(MSDOS) || defined(OS2)

CANVAS_scriptdir = RelativePathToGnuplot(GNUPLOT_JS_DIR);

/* use hardcoded _absolute_ path */

CANVAS_scriptdir = strdup(GNUPLOT_JS_DIR);

CANVAS_scriptdir = strdup("");

#endif /* GNUPLOT_JS_DIR */

}

len = strlen(CANVAS_scriptdir);

# if defined(_WIN32) || defined(MSDOS) || defined(OS2)

if (*CANVAS_scriptdir && CANVAS_scriptdir[len-1] != '\\' && CANVAS_scriptdir[len-1] != '/') {

CANVAS_scriptdir = gp_realloc(CANVAS_scriptdir, len+2, "jsdir");

if (CANVAS_scriptdir[len-1] == '\\') /* use backslash if used in jsdir, otherwise slash */

strcat(CANVAS_scriptdir, "\\");

else

strcat(CANVAS_scriptdir, "/");

}

if (*CANVAS_scriptdir && CANVAS_scriptdir[len-1] != '/') {

CANVAS_scriptdir = gp_realloc(CANVAS_scriptdir, len+2, "jsdir");

strcat(CANVAS_scriptdir,"/");

}

if (CANVAS_standalone) {

fprintf(gpoutfile,

"<!DOCTYPE HTML>\n"

"<html>\n"

"<head>\n"

"<title>%s</title>\n",

CANVAS_title ? CANVAS_title : "Gnuplot Canvas Graph"

);

if (encoding == S_ENC_UTF8 || encoding == S_ENC_DEFAULT)

fprintf(gpoutfile,

"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n"

);

fprintf(gpoutfile,

"<!--[if IE]><script type=\"text/javascript\" src=\"excanvas.js\"></script><![endif]-->\n"

"<script src=\"%s%s.js\"></script>\n"

"<script src=\"%sgnuplot_common.js\"></script>\n"

, CANVAS_scriptdir

, (encoding == S_ENC_UTF8) ? "canvasmath" : "canvastext"

, CANVAS_scriptdir);

if (canvas_dashed)

fprintf(gpoutfile,

"<script src=\"%sgnuplot_dashedlines.js\"></script>\n"

, CANVAS_scriptdir);

if (CANVAS_mouseable) {

fprintf(gpoutfile,

"<script src=\"%sgnuplot_mouse.js\"></script>\n"

, CANVAS_scriptdir);

fprintf(gpoutfile,

"<script type=\"text/javascript\"> "

"gnuplot.help_URL = \"%s/canvas_help.html\"; </script>\n"

, CANVAS_scriptdir);

} else {

fprintf(gpoutfile,

"<script type=\"text/javascript\">"

"gnuplot.init = function() {};</script>\n");

}

fprintf(gpoutfile,

"<script type=\"text/javascript\">\n"

"var canvas, ctx;\n"

"gnuplot.grid_lines = true;\n"

"gnuplot.zoomed = false;\n"

"gnuplot.active_plot_name = \"gnuplot_canvas\";\n\n"

"function gnuplot_canvas() {\n"

"canvas = document.getElementById(\"gnuplot_canvas\");\n"

"ctx = canvas.getContext(\"2d\");\n"

);

} else {

fprintf(gpoutfile,

"function %s() {\n"

"canvas = document.getElementById(\"%s\");\n"

"ctx = canvas.getContext(\"2d\");\n",

CANVAS_name, CANVAS_name

);

fprintf(gpoutfile,

"// Suppress refresh on mouseover if this was the plot we just left\n"

"if ((gnuplot.active_plot == %s && gnuplot.display_is_uptodate)) return;\n"

"else gnuplot.display_is_uptodate = true;\n",

CANVAS_name);

fprintf(gpoutfile,

"// Reinitialize mouse tracking and zoom for this particular plot\n"

"if ((typeof(gnuplot.active_plot) == \"undefined\" || gnuplot.active_plot != %s) && typeof(gnuplot.mouse_update) != \"undefined\") {\n"

" gnuplot.active_plot_name = \"%s\";\n"

" gnuplot.active_plot = %s;\n"

" canvas.onmousemove = gnuplot.mouse_update;\n"

" canvas.onmouseup = gnuplot.zoom_in;\n"

" canvas.onmousedown = gnuplot.saveclick;\n"

" canvas.onkeypress = gnuplot.do_hotkey;\n"

" if (canvas.attachEvent) {canvas.attachEvent('mouseover', %s);}\n"

" else if (canvas.addEventListener) {canvas.addEventListener('mouseover', %s, false);} \n"

" gnuplot.zoomed = false;\n"

" gnuplot.zoom_axis_width = 0;\n"

" gnuplot.zoom_in_progress = false;\n",

CANVAS_name, CANVAS_name, CANVAS_name, CANVAS_name, CANVAS_name);

fprintf(gpoutfile,

" gnuplot.polar_mode = %s;\n"

" gnuplot.polar_theta0 = %d;\n"

" gnuplot.polar_sense = %d;\n"

" ctx.clearRect(0,0,%d,%d);\n"

"}\n",

(polar) ? "true" : "false", (int)theta_origin, (int)theta_direction,

(int)(term->xmax / CANVAS_OVERSAMPLE), (int)(term->ymax / CANVAS_OVERSAMPLE));

}

fprintf(gpoutfile, "// Gnuplot version %s.%s\n", gnuplot_version, gnuplot_patchlevel);

fprintf(gpoutfile,

"// short forms of commands provided by gnuplot_common.js\n"

"function DT (dt) {gnuplot.dashtype(dt);};\n"

"function DS (x,y) {gnuplot.dashstart(x,y);};\n"

"function DL (x,y) {gnuplot.dashstep(x,y);};\n"

"function M (x,y) {if (gnuplot.pattern.length > 0) DS(x,y); else gnuplot.M(x,y);};\n"

"function L (x,y) {if (gnuplot.pattern.length > 0) DL(x,y); else gnuplot.L(x,y);};\n"

"function Dot (x,y) {gnuplot.Dot(x/10.,y/10.);};\n"

"function Pt (N,x,y,w) {gnuplot.Pt(N,x/10.,y/10.,w/10.);};\n"

"function R (x,y,w,h) {gnuplot.R(x,y,w,h);};\n"

"function T (x,y,fontsize,justify,string) {gnuplot.T(x,y,fontsize,justify,string);};\n"

"function TR (x,y,angle,fontsize,justify,string) {gnuplot.TR(x,y,angle,fontsize,justify,string);};\n"

"function bp (x,y) {gnuplot.bp(x,y);};\n"

"function cfp () {gnuplot.cfp();};\n"

"function cfsp() {gnuplot.cfsp();};\n"

"\n"

);

fprintf(gpoutfile,

"gnuplot.hypertext_list = [];\n"

"gnuplot.on_hypertext = -1;\n"

"function Hypertext(x,y,w,text) {\n"

" newtext = {x:x, y:y, w:w, text:text};\n"

" gnuplot.hypertext_list.push(newtext);\n"

"}\n"

);

fprintf(gpoutfile,

"gnuplot.dashlength = %d;\n",

(int)(400 * canvas_dashlength_factor)

);

fprintf(gpoutfile,

"ctx.lineCap = \"%s\"; ctx.lineJoin = \"%s\";\n",

canvas_linecap == ROUNDED ? "round" : canvas_linecap == SQUARE ? "square" : "butt",

canvas_linecap == ROUNDED ? "round" : "miter"

);

if (*CANVAS_background) {

fprintf(gpoutfile,

"ctx.fillStyle = \"%s\";\n"

"ctx.fillRect(0,0,%d,%d);\n",

CANVAS_background,

(int)(term->xmax / CANVAS_OVERSAMPLE),

(int)(term->ymax / CANVAS_OVERSAMPLE));

}

fprintf(gpoutfile,

"CanvasTextFunctions.enable(ctx);\n"

"ctx.strokeStyle = \" rgb(215,215,215)\";\n"

"ctx.lineWidth = %.1g;\n\n",

canvas_linewidth

);

}

static void

CANVAS_mouse_param( char *gp_name, const char *js_name )

{

struct udvt_entry *udv;

if ((udv = add_udv_by_name(gp_name))) {

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

fprintf(gpoutfile, "%s = ", js_name);

fprintf(gpoutfile, PLD, udv->udv_value.v.int_val);

fprintf(gpoutfile, "\n");

} else if (udv->udv_value.type == CMPLX) {

fprintf(gpoutfile, "%s = %g;\n", js_name, udv->udv_value.v.cmplx_val.real);

}

}

}

TERM_PUBLIC void

CANVAS_text()

{

struct axis *this_axis;

CANVAS_finish();

/* FIXME: I am not sure whether these variable names should always be the */

/* same, so that they are re-used by all plots in a document, or whether */

/* they should be tied to the function name and hence private. */

if (TRUE) {

fprintf(gpoutfile, "\n// plot boundaries and axis scaling information for mousing \n");

fprintf(gpoutfile, "gnuplot.plot_term_xmax = %d;\n", (int)(term->xmax / CANVAS_OVERSAMPLE));

fprintf(gpoutfile, "gnuplot.plot_term_ymax = %d;\n", (int)(term->ymax / CANVAS_OVERSAMPLE));

fprintf(gpoutfile, "gnuplot.plot_xmin = %.1f;\n", (double)plot_bounds.xleft / CANVAS_OVERSAMPLE);

fprintf(gpoutfile, "gnuplot.plot_xmax = %.1f;\n", (double)plot_bounds.xright / CANVAS_OVERSAMPLE);

fprintf(gpoutfile, "gnuplot.plot_ybot = %.1f;\n", (double)(term->ymax-plot_bounds.ybot) / CANVAS_OVERSAMPLE);

fprintf(gpoutfile, "gnuplot.plot_ytop = %.1f;\n", (double)(term->ymax-plot_bounds.ytop) / CANVAS_OVERSAMPLE);

fprintf(gpoutfile, "gnuplot.plot_width = %.1f;\n", (double)(plot_bounds.xright - plot_bounds.xleft) / CANVAS_OVERSAMPLE);

fprintf(gpoutfile, "gnuplot.plot_height = %.1f;\n", (double)(plot_bounds.ytop - plot_bounds.ybot) / CANVAS_OVERSAMPLE);

/* Get true axis ranges as used in the plot */

update_gpval_variables(1);

#define MOUSE_PARAM( GP_NAME, js_NAME ) CANVAS_mouse_param( GP_NAME, js_NAME)

if (axis_array[FIRST_X_AXIS].datatype != DT_TIMEDATE) {

MOUSE_PARAM("GPVAL_X_MIN", "gnuplot.plot_axis_xmin");

MOUSE_PARAM("GPVAL_X_MAX", "gnuplot.plot_axis_xmax");

}

/* FIXME: Should this inversion be done at a higher level? */

if (is_3d_plot && splot_map) {

MOUSE_PARAM("GPVAL_Y_MAX", "gnuplot.plot_axis_ymin");

MOUSE_PARAM("GPVAL_Y_MIN", "gnuplot.plot_axis_ymax");

} else {

MOUSE_PARAM("GPVAL_Y_MIN", "gnuplot.plot_axis_ymin");

MOUSE_PARAM("GPVAL_Y_MAX", "gnuplot.plot_axis_ymax");

}

if (polar) {

fprintf(gpoutfile, "gnuplot.plot_axis_rmin = %g;\n",

(R_AXIS.autoscale & AUTOSCALE_MIN) ? 0.0 : R_AXIS.set_min);

fprintf(gpoutfile, "gnuplot.plot_axis_rmax = %g;\n", R_AXIS.set_max);

}

if ((axis_array[SECOND_X_AXIS].ticmode & TICS_MASK) != NO_TICS) {

MOUSE_PARAM("GPVAL_X2_MIN", "gnuplot.plot_axis_x2min");

MOUSE_PARAM("GPVAL_X2_MAX", "gnuplot.plot_axis_x2max");

} else

fprintf(gpoutfile, "gnuplot.plot_axis_x2min = \"none\"\n");

if (axis_array[SECOND_X_AXIS].linked_to_primary

&& axis_array[FIRST_X_AXIS].link_udf->at) {

fprintf(gpoutfile, "gnuplot.x2_mapping = function(x) { return x; };");

fprintf(gpoutfile, " // replace returned value with %s\n",

axis_array[FIRST_X_AXIS].link_udf->definition);

}

if ((axis_array[SECOND_Y_AXIS].ticmode & TICS_MASK) != NO_TICS) {

MOUSE_PARAM("GPVAL_Y2_MIN", "gnuplot.plot_axis_y2min");

MOUSE_PARAM("GPVAL_Y2_MAX", "gnuplot.plot_axis_y2max");

} else

fprintf(gpoutfile, "gnuplot.plot_axis_y2min = \"none\"\n");

if (axis_array[SECOND_Y_AXIS].linked_to_primary

&& axis_array[FIRST_Y_AXIS].link_udf->at) {

fprintf(gpoutfile, "gnuplot.y2_mapping = function(y) { return y; };");

fprintf(gpoutfile, " // replace returned value with %s\n",

axis_array[FIRST_Y_AXIS].link_udf->definition);

}

#undef MOUSE_PARAM

/*

# define is_nonlinear(axis) ((axis)->linked_to_primary != NULL \

&& (axis)->link_udf->at != NULL \

&& (axis)->index == -((axis)->linked_to_primary->index))

this_axis = &axis_array[FIRST_X_AXIS];

fprintf(gpoutfile, "gnuplot.plot_logaxis_x = %d;\n",

this_axis->log ? 1

: (mouse_mode == MOUSE_COORDINATES_FUNCTION || is_nonlinear(this_axis)) ? -1

: 0);

this_axis = &axis_array[FIRST_Y_AXIS];

fprintf(gpoutfile, "gnuplot.plot_logaxis_y = %d;\n",

this_axis->log ? 1

: (mouse_mode == MOUSE_COORDINATES_FUNCTION || is_nonlinear(this_axis)) ? -1

: 0);

if (polar)

fprintf(gpoutfile, "gnuplot.plot_logaxis_r = %d;\n",

axis_array[POLAR_AXIS].log ? 1: 0);

if (axis_array[FIRST_X_AXIS].datatype == DT_TIMEDATE) {

/* May need to reconstruct time to millisecond precision */

fprintf(gpoutfile, "gnuplot.plot_axis_xmin = %.3f;\n",

axis_array[FIRST_X_AXIS].min);

fprintf(gpoutfile, "gnuplot.plot_axis_xmax = %.3f;\n",

axis_array[FIRST_X_AXIS].max);

fprintf(gpoutfile, "gnuplot.plot_timeaxis_x = \"%s\";\n",

(mouse_alt_string) ? mouse_alt_string

: (mouse_mode == 4) ? "Date"

: (mouse_mode == 5) ? "Time"

: "DateTime"

);

} else if (axis_array[FIRST_X_AXIS].datatype == DT_DMS) {

fprintf(gpoutfile, "gnuplot.plot_timeaxis_x = \"%s\";\n",

(mouse_alt_string) ? mouse_alt_string : "DMS");

} else

fprintf(gpoutfile, "gnuplot.plot_timeaxis_x = \"\";\n");

if (axis_array[FIRST_Y_AXIS].datatype == DT_DMS) {

fprintf(gpoutfile, "gnuplot.plot_timeaxis_y = \"%s\";\n",

(mouse_alt_string) ? mouse_alt_string : "DMS");

} else

fprintf(gpoutfile, "gnuplot.plot_timeaxis_y = \"\";\n");

fprintf(gpoutfile, "gnuplot.plot_axis_width = gnuplot.plot_axis_xmax - gnuplot.plot_axis_xmin;\n");

fprintf(gpoutfile, "gnuplot.plot_axis_height = gnuplot.plot_axis_ymax - gnuplot.plot_axis_ymin;\n");

} /* End of section writing out variables for mousing */

/* This is the end of the javascript plot */

fprintf(gpoutfile, "}\n");

#ifdef WRITE_PNG_IMAGE

/* Link internal image structures to external PNG files */

if (imagelist) {

canvas_imagefile *thisimage = imagelist;

char *base_name = CANVAS_name ? CANVAS_name : "gp";

while (thisimage != NULL) {

fprintf(stderr," linking image %d to external file %s\n",

thisimage->imageno, thisimage->filename);

fprintf(gpoutfile, " var %s_image_%02d = new Image();",

base_name, thisimage->imageno);

fprintf(gpoutfile, " %s_image_%02d.src = \"%s\";\n",

base_name, thisimage->imageno, thisimage->filename);

imagelist = thisimage->next;

free(thisimage->filename);

free(thisimage);

thisimage = imagelist;

}

}

if (CANVAS_standalone) {

fprintf(gpoutfile,

"</script>\n"

"<link type=\"text/css\" href=\"%sgnuplot_mouse.css\" rel=\"stylesheet\">\n"

"</head>\n"

"<body onload=\"gnuplot_canvas(); gnuplot.init();\" oncontextmenu=\"return false;\">\n\n"

"<div class=\"gnuplot\">\n",

CANVAS_scriptdir ? CANVAS_scriptdir : ""

);

/* Pattern-fill requires having a canvas element to hold a template

fprintf(gpoutfile,

"<canvas id=\"Tile\" width=\"32\" height=\"32\" hidden></canvas>\n");

/* The format of the plot box and in particular the mouse tracking box

if (CANVAS_mouseable) {

int i;

fprintf(gpoutfile,

"<table class=\"mbleft\"><tr><td class=\"mousebox\">\n"

"<table class=\"mousebox\" border=0>\n"

" <tr><td class=\"mousebox\">\n"

" <table class=\"mousebox\" id=\"gnuplot_mousebox\" border=0>\n"

" <tr><td class=\"mbh\"></td></tr>\n"

" <tr><td class=\"mbh\">\n"

" <table class=\"mousebox\">\n"

" <tr>\n"

" <td class=\"icon\"></td>\n"

" <td class=\"icon\" onclick=gnuplot.toggle_grid><img src=\"%sgrid.png\" id=\"gnuplot_grid_icon\" class=\"icon-image\" alt=\"#\" title=\"toggle grid\"></td>\n"

" <td class=\"icon\" onclick=gnuplot.unzoom><img src=\"%spreviouszoom.png\" id=\"gnuplot_unzoom_icon\" class=\"icon-image\" alt=\"unzoom\" title=\"unzoom\"></td>\n"

" <td class=\"icon\" onclick=gnuplot.rezoom><img src=\"%snextzoom.png\" id=\"gnuplot_rezoom_icon\" class=\"icon-image\" alt=\"rezoom\" title=\"rezoom\"></td>\n"

" <td class=\"icon\" onclick=gnuplot.toggle_zoom_text><img src=\"%stextzoom.png\" id=\"gnuplot_textzoom_icon\" class=\"icon-image\" alt=\"zoom text\" title=\"zoom text with plot\"></td>\n"

" <td class=\"icon\" onclick=gnuplot.popup_help()><img src=\"%shelp.png\" id=\"gnuplot_help_icon\" class=\"icon-image\" alt=\"?\" title=\"help\"></td>\n"

" </tr>\n",

CANVAS_scriptdir ? CANVAS_scriptdir : "", CANVAS_scriptdir ? CANVAS_scriptdir : "",

CANVAS_scriptdir ? CANVAS_scriptdir : "", CANVAS_scriptdir ? CANVAS_scriptdir : "",

CANVAS_scriptdir ? CANVAS_scriptdir : ""

);

/* Table row of plot toggle icons goes here */

for (i=1; i<=6*((canvas_state.plotno+5)/6); i++) {

if ((i%6) == 1)

fprintf(gpoutfile, " <tr>\n");

if (i<=canvas_state.plotno)

fprintf(gpoutfile,

" <td class=\"icon\" onclick=gnuplot.toggle_plot(\"gp_plot_%d\")>%d</td>\n",i,i);

else

fprintf(gpoutfile,

" <td class=\"icon\" > </td>\n");

if ((i%6) == 0)

fprintf(gpoutfile, " </tr>\n");

}

fprintf(gpoutfile,

" </table>\n"

" </td></tr>\n"

"</table></td></tr><tr><td class=\"mousebox\">\n"

);

fprintf(gpoutfile,

"<table class=\"mousebox\" id=\"gnuplot_mousebox\" border=1>\n"

"<tr> <td class=\"mb0\">x&nbsp;</td> <td class=\"mb1\"><span id=\"gnuplot_canvas_x\">&nbsp;</span></td> </tr>\n"

"<tr> <td class=\"mb0\">y&nbsp;</td> <td class=\"mb1\"><span id=\"gnuplot_canvas_y\">&nbsp;</span></td> </tr>\n"

);

if ((axis_array[SECOND_X_AXIS].ticmode & TICS_MASK) != NO_TICS)

fprintf(gpoutfile,

"<tr> <td class=\"mb0\">x2&nbsp;</td> <td class=\"mb1\"><span id=\"gnuplot_canvas_x2\">&nbsp;</span></td> </tr>\n");

if ((axis_array[SECOND_Y_AXIS].ticmode & TICS_MASK) != NO_TICS)

fprintf(gpoutfile,

"<tr> <td class=\"mb0\">y2&nbsp;</td> <td class=\"mb1\"><span id=\"gnuplot_canvas_y2\">&nbsp;</span></td> </tr>\n");

fprintf(gpoutfile,

"</table></td></tr>\n"

"</table>\n"

);

fprintf(gpoutfile,

"</td><td>\n"

);

} /* End if (CANVAS_mouseable) */

fprintf(gpoutfile,

"<table class=\"plot\">\n"

"<tr><td>\n"

" <canvas id=\"gnuplot_canvas\" width=\"%d\" height=\"%d\" tabindex=\"0\">\n"

" Sorry, your browser seems not to support the HTML 5 canvas element\n"

" </canvas>\n"

"</td></tr>\n"

"</table>\n",

(int)(term->xmax/CANVAS_OVERSAMPLE), (int)(term->ymax/CANVAS_OVERSAMPLE)

);

if (CANVAS_mouseable) {

fprintf(gpoutfile,

"</td></tr></table>\n"

);

}

fprintf(gpoutfile,

"</div>\n\n"

"</body>\n"

"</html>\n"

);

}

fflush(gpoutfile);

}

TERM_PUBLIC void

CANVAS_reset()

{

;

}

TERM_PUBLIC void

CANVAS_linetype(int linetype)

{

/* NB: These values are manipulated as numbers; */

/* it does not work to give only the color name */

static const char * pen_type[17] = {

" rgb(255,255,255)", /* should be background */

" rgb(000,000,000)", /* black */

" rgb(160,160,160)", /* grey */

" rgb(255,000,000)", /* red */

" rgb(000,171,000)", /* green */

" rgb(000,000,225)", /* blue */

" rgb(190,000,190)", /* purple */

" rgb(000,255,255)", /* cyan */

" rgb(021,117,069)", /* pine green*/

" rgb(000,000,148)", /* navy */

" rgb(255,153,000)", /* orange */

" rgb(000,153,161)", /* green blue*/

" rgb(214,214,069)", /* olive*/

" rgb(163,145,255)", /* cornflower*/

" rgb(255,204,000)", /* gold*/

" rgb(214,000,120)", /* mulberry*/

" rgb(171,214,000)", /* green yellow*/

};

/* FIXME if (linetype == canvas_line_type) return; */

canvas_line_type = linetype;

CANVAS_finish();

if (linetype >= 14)

linetype %= 14;

if (linetype <= LT_NODRAW) /* LT_NODRAW, LT_BACKGROUND, LT_UNDEFINED */

linetype = -3;

if (linetype == -3 && *CANVAS_background)

strcpy(canvas_state.color,CANVAS_background);

else

strcpy(canvas_state.color,pen_type[linetype + 3]);

if (strcmp(canvas_state.color, canvas_state.previous_color)) {

fprintf(gpoutfile, "ctx.strokeStyle = \"%s\";\n", canvas_state.color);

strcpy(canvas_state.previous_color, canvas_state.color);

}

if (canvas_line_type == LT_NODRAW)

CANVAS_dashtype(DASHTYPE_NODRAW, NULL);

}

TERM_PUBLIC void

CANVAS_dashtype(int type, t_dashtype *custom_dash_type)

{

if (canvas_line_type == LT_NODRAW)

type = DASHTYPE_NODRAW;

if (canvas_line_type == LT_AXIS)

type = DASHTYPE_AXIS;

switch (type) {

case DASHTYPE_AXIS:

fprintf(gpoutfile, "DT(gnuplot.dashpattern3);\n");

break;

case DASHTYPE_SOLID:

if (canvas_dash_type != DASHTYPE_SOLID)

fprintf(gpoutfile, "DT(gnuplot.solid);\n");

break;

case DASHTYPE_NODRAW:

fprintf(gpoutfile, "DT([0.0,1.0]);\n");

break;

default:

type = type % 5;

if (canvas_dash_type != type)

fprintf(gpoutfile, "DT(gnuplot.dashpattern%1d);\n", type + 1);

break;

case DASHTYPE_CUSTOM:

if (custom_dash_type) {

double length = 0;

double cumulative = 0;

int i;

for (i = 0; i < DASHPATTERN_LENGTH && custom_dash_type->pattern[i] > 0; i++)

length += custom_dash_type->pattern[i];

fprintf(gpoutfile, "DT([");

for (i = 0; i < DASHPATTERN_LENGTH && custom_dash_type->pattern[i] > 0; i++) {

cumulative += custom_dash_type->pattern[i];

fprintf(gpoutfile, " %4.2f,", cumulative / length);

}

fprintf(gpoutfile, " 0]);\n");

}

break;

}

canvas_dash_type = type;

}

TERM_PUBLIC void

CANVAS_move(unsigned int arg_x, unsigned int arg_y)

{

if (canvas_in_a_path && (canvas_x == arg_x) && (canvas_y == arg_y)) {

return;

}

CANVAS_start();

fprintf(gpoutfile,

"M(%u,%u);\n",

arg_x, canvas_ymax - arg_y);

canvas_x = arg_x;

canvas_y = arg_y;

}

TERM_PUBLIC void

CANVAS_vector(unsigned int arg_x, unsigned int arg_y)

{

if ((canvas_x == arg_x) && (canvas_y == arg_y))

return;

if (!canvas_in_a_path) {

/* Force a new path */

CANVAS_move(canvas_x, canvas_y);

}

fprintf(gpoutfile,

"L(%u,%u);\n",

arg_x, canvas_ymax - arg_y

);

canvas_x = arg_x;