/* Hello, Emacs, this is -*-C-*-
 * $Id: dumb.trm,v 1.33.2.1 2015/08/14 22:29:25 sfeam Exp $
 *
 */

/* GNUPLOT - dumb.trm */

/*[
 * Copyright 1991 - 1993, 1998, 2004   Thomas Williams, Colin Kelley
 *
 * Permission to use, copy, and distribute this software and its
 * documentation for any purpose with or without fee is hereby granted,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.
 *
 * Permission to modify the software is granted, but not the right to
 * distribute the complete modified source code.  Modifications are to
 * be distributed as patches to the released version.  Permission to
 * distribute binaries produced by compiling modified sources is granted,
 * provided you
 *   1. distribute the corresponding source modifications from the
 *    released version in the form of a patch file along with the binaries,
 *   2. add special version identification to distinguish your version
 *    in addition to the base release version number,
 *   3. provide your name and address as the primary contact for the
 *    support of your modified version, and
 *   4. retain our contact information in regard to use of the base
 *    software.
 * Permission to distribute the released version of the source code along
 * with corresponding source modifications in the form of a patch file is
 * granted with same provisions 2 through 4 for binary distributions.
 *
 * This software is provided "as is" without express or implied warranty
 * to the extent permitted by applicable law.
]*/

/*
 * This file is included by ../term.c.
 *
 * This terminal driver supports:
 *   DUMB terminals
 *
 * AUTHORS
 *   Francois Pinard, 91-04-03
 *           INTERNET: pinard@iro.umontreal.ca
 *
 *   Ethan A Merritt Nov 2003
 *	Added support for enhanced text mode.
 *	Yes, this is frivolous, but it serves as an example for
 *	adding enhanced text to other terminals.  You can disable
 *	it by adding a line
 *	#define NO_DUMB_ENHANCED_SUPPORT
 *
 * send your comments or suggestions to (gnuplot-info@lists.sourceforge.net).
 *
 */
#include "driver.h"

#ifdef TERM_REGISTER
register_term(dumb_driver)
#endif

#ifdef TERM_PROTO
TERM_PUBLIC void DUMB_options __PROTO((void));
TERM_PUBLIC void DUMB_init __PROTO((void));
TERM_PUBLIC void DUMB_graphics __PROTO((void));
TERM_PUBLIC void DUMB_text __PROTO((void));
TERM_PUBLIC void DUMB_reset __PROTO((void));
TERM_PUBLIC void DUMB_linetype __PROTO((int linetype));
TERM_PUBLIC void DUMB_move __PROTO((unsigned int x, unsigned int y));
TERM_PUBLIC void DUMB_point __PROTO((unsigned int x, unsigned int y,
				     int point));
TERM_PUBLIC void DUMB_vector __PROTO((unsigned int x, unsigned int y));
TERM_PUBLIC void DUMB_put_text __PROTO((unsigned int x, unsigned int y,
					const char *str));
TERM_PUBLIC void DUMB_arrow __PROTO((unsigned int sx, unsigned int sy,
				     unsigned int ex, unsigned int ey,
				     int head));

#ifndef NO_DUMB_ENHANCED_SUPPORT
/* To support "set term dumb enhanced" (don't ask why!) */
TERM_PUBLIC void ENHdumb_put_text __PROTO((unsigned int x, unsigned int y, const char str[]));
TERM_PUBLIC void ENHdumb_OPEN __PROTO((char * fontname, double fontsize,
	                            double base, TBOOLEAN widthflag, TBOOLEAN showflag,
				    int overprint));
TERM_PUBLIC void ENHdumb_FLUSH __PROTO((void));
#else
#define ENHdumb_put_text NULL
#endif


#define DUMB_XMAX 79
#define DUMB_YMAX 24

#endif /* TERM_PROTO */

#ifdef TERM_BODY

#define DUMB_AXIS_CONST '\1'
#define DUMB_BORDER_CONST '\2'

/* UTF-8 support */
#ifdef HAVE_STDLIB_H
#define DUMB_UTF8
 typedef int32_t charcell;
#else
 typedef char charcell;
#endif

/* matrix of characters */
static charcell *dumb_matrix = NULL;
/* matrix of priority at each position */
static char *dumb_priority = NULL;
/* current character used to draw */
static char dumb_pen;
/* current X position */
static int dumb_x;
/* current Y position */
static int dumb_y;
static int dumb_xmax = DUMB_XMAX;
static int dumb_ymax = DUMB_YMAX;
static TBOOLEAN dumb_feed = TRUE;

#define DUMB_PIXEL(x,y) dumb_matrix[dumb_xmax*(y)+(x)]

static void dumb_set_pixel __PROTO((int x, int y, int v, int p));

enum DUMB_id { DUMB_FEED, DUMB_NOFEED, DUMB_ENH, DUMB_NOENH, 
               DUMB_SIZE, DUMB_ASPECT, DUMB_OTHER };

static struct gen_table DUMB_opts[] =
{
    { "f$eed", DUMB_FEED },
    { "nof$eed", DUMB_NOFEED },
    { "enh$anced", DUMB_ENH },
    { "noe$nhanced", DUMB_NOENH },
    { "size", DUMB_SIZE },
    { "aspect", DUMB_ASPECT },
    { NULL, DUMB_OTHER }
};

TERM_PUBLIC void
DUMB_options()
{
    int x, y;

    while (!END_OF_COMMAND) {
	switch(lookup_table(&DUMB_opts[0],c_token)) {
	case DUMB_FEED:
	    c_token++;
	    dumb_feed = TRUE;
	    break;
	case DUMB_NOFEED:
	    c_token++;
	    dumb_feed = FALSE;
	    break;
#ifndef NO_DUMB_ENHANCED_SUPPORT
	case DUMB_ENH:
	    c_token++;
	    term->put_text = ENHdumb_put_text;
	    term->flags |= TERM_ENHANCED_TEXT;
	    break;
	case DUMB_NOENH:
	    c_token++;
	    term->put_text = DUMB_put_text;
	    term->flags &= ~TERM_ENHANCED_TEXT;
	    break;
#endif
	case DUMB_ASPECT:
	    c_token++;
	    x = int_expression();
	    y = 1;
	    if (!END_OF_COMMAND && equals(c_token, ",")) {
		c_token++;
		y = int_expression();
	    }
	    if (x <= 0) x = 1;
	    if (y <= 0) y = 1;
	    term->h_tic = x;
	    term->v_tic = y;
 	    break;
	case DUMB_SIZE:
	    c_token++;
	    /* Fall through */
	case DUMB_OTHER:
	default:
	    x = int_expression();
	    if (!END_OF_COMMAND) {
		if (equals(c_token,","))
		    c_token++;
		y = int_expression();
		dumb_xmax = term->xmax = x;
		dumb_ymax = term->ymax = y;
	    }
 	    break;
	}
    }

    sprintf(term_options, "%sfeed %s size %d, %d aspect %i, %i",
	    dumb_feed ? "" : "no",
	    term->put_text == ENHdumb_put_text ? "enhanced" : "",
	    dumb_xmax, dumb_ymax,
	    term->h_tic, term->v_tic);
}


static void
dumb_set_pixel(int x, int y, int v, int p)
{
    char *charpixel;

    if ((unsigned int) x <= dumb_xmax &&	/* ie x>=0 && x<=dumb_xmax */
	(unsigned int) y <= dumb_ymax &&
	p > dumb_priority[dumb_xmax * y + x]) {
	    dumb_priority[dumb_xmax * y + x] = p;
	    charpixel = (char *)(&dumb_matrix[dumb_xmax * y + x]);
	    /* null-terminate single ascii character (needed for UTF-8) */
	    dumb_matrix[dumb_xmax * y + x] = 0;
	    *charpixel = v;
    }
}


TERM_PUBLIC void
DUMB_init()
{
    int size = (dumb_xmax+1) * (dumb_ymax+1);

    dumb_matrix = gp_realloc(dumb_matrix, size*sizeof(charcell), "dumb terminal");
    dumb_priority = gp_realloc(dumb_priority, size*sizeof(char), "dumb terminal");
}


TERM_PUBLIC void
DUMB_graphics()
{
    int i;
    int size = (dumb_xmax+1) * (dumb_ymax+1);
    charcell *pm = dumb_matrix;

    memset(dumb_matrix, 0, size * sizeof(charcell));
    memset(dumb_priority, 0, size * sizeof(char));

    for (i=0; i<size; i++) {
	char *c = (char *)pm++;
	*c = ' ';
    }
}


TERM_PUBLIC void
DUMB_text()
{
    int x, y;

    putc('\f', gpoutfile);
    for (y = dumb_ymax - 1; y >= 0; y--) {
	for (x = 0; x < dumb_xmax; x++) {
#ifdef DUMB_UTF8
	    char *c = (char *)(&dumb_matrix[dumb_xmax*y + x]);
	    fputs(c, gpoutfile);
#else
	    fputc(DUMB_PIXEL(x, y), gpoutfile);
#endif
	}
	if (dumb_feed || y > 0)
	    putc('\n', gpoutfile);
    }
    fflush(gpoutfile);
}


TERM_PUBLIC void
DUMB_reset()
{
    free(dumb_matrix);
    free(dumb_priority);
    dumb_matrix = NULL;
    dumb_priority = NULL;
}


TERM_PUBLIC void
DUMB_linetype(int linetype)
{
    static char pen_type[7] = { '*', '#', '$', '%', '@', '&', '=' };

    if (linetype == LT_BLACK)
	dumb_pen = DUMB_BORDER_CONST;
    else if (linetype == LT_AXIS)
	dumb_pen = DUMB_AXIS_CONST;
    else if (linetype <= LT_NODRAW)
	dumb_pen = ' ';
    else {
	linetype = linetype % 7;
	dumb_pen = pen_type[linetype];
    }
}


TERM_PUBLIC void
DUMB_move(unsigned int x, unsigned int y)
{
    dumb_x = x;
    dumb_y = y;
}


TERM_PUBLIC void
DUMB_point(unsigned int x, unsigned int y, int point)
{
    dumb_set_pixel(x, y, point == -1 ? '.' : point % 26 + 'A', 4);
}


TERM_PUBLIC void
DUMB_vector(unsigned int arg_x, unsigned int arg_y)
{
    int x = arg_x;		/* we need signed int, since
				 * unsigned-signed=unsigned and */
    int y = arg_y;		/* abs and cast to double wouldn't work */
    char pen, pen1;
    int priority;
    int delta;

    if (ABS(y - dumb_y) > ABS(x - dumb_x)) {
	switch (dumb_pen) {
	case DUMB_AXIS_CONST:
	    pen = ':';
	    pen1 = '+';
	    priority = 1;
	    break;

	case DUMB_BORDER_CONST:
	    pen = '|';
	    pen1 = '+';
	    priority = 2;
	    break;

	default:
	    pen = dumb_pen;
	    pen1 = dumb_pen;
	    priority = 3;
	    break;
	}
	dumb_set_pixel(dumb_x, dumb_y, pen1, priority);
	for (delta = 1; delta < ABS(y - dumb_y); delta++) {
	    dumb_set_pixel(dumb_x  + (int) ((double) (x - dumb_x) *
					    delta / ABS(y - dumb_y) + 0.5),
			   dumb_y + delta * sign(y - dumb_y), pen, priority);
	}
	dumb_set_pixel(x, y, pen1, priority);
    } else if (ABS(x - dumb_x) > ABS(y - dumb_y)) {
	switch (dumb_pen) {
	case DUMB_AXIS_CONST:
	    pen = '.';
	    pen1 = '+';
	    priority = 1;
	    break;

	case DUMB_BORDER_CONST:
	    pen = '-';
	    pen1 = '+';
	    priority = 2;
	    break;

	default:
	    pen = dumb_pen;
	    pen1 = dumb_pen;
	    priority = 3;
	    break;
	}
	dumb_set_pixel(dumb_x, dumb_y, pen1, priority);
	for (delta = 1; delta < ABS(x - dumb_x); delta++)
	    dumb_set_pixel(dumb_x + delta * sign(x - dumb_x),
			   dumb_y +
			   (int) ((double) (y - dumb_y) * delta / ABS(x - dumb_x)
				  + 0.5),
			   pen, priority);
	dumb_set_pixel(x, y, pen1, priority);
    } else {
	switch (dumb_pen) {
	case DUMB_AXIS_CONST:	/* zero length axis */
	    pen = '+';
	    priority = 1;
	    break;

	case DUMB_BORDER_CONST:	/* zero length border */
	    pen = '+';
	    priority = 2;
	    break;

	default:
	    pen = dumb_pen;
	    priority = 3;
	    break;
	}
	for (delta = 0; delta <= ABS(x - dumb_x); delta++)
	    dumb_set_pixel(dumb_x + delta * sign(x - dumb_x),
			   dumb_y + delta * sign(y - dumb_y),
			   pen, priority);
    }
    dumb_x = x;
    dumb_y = y;
}

static void
utf8_copy_one(char *dest, char *orig)
{
    *((charcell *)dest) = 0;	/* zero-fill */
    *dest = *orig;		/* first char */
    if (encoding != S_ENC_UTF8)
	return;
    if ((*dest & 0x80) == 0)	/* ascii char */
	return;
    orig++; dest++;
    while ((*orig & 0xc0) == 0x80)
	*dest++ = *orig++;
}

TERM_PUBLIC void
DUMB_put_text(unsigned int x, unsigned int y, const char *str)
{
    int i, length;

    length = gp_strlen(str);
    if (x + length > dumb_xmax)
	x = GPMAX(0, dumb_xmax - length);

#ifdef DUMB_UTF8
    for (i = 0; i < length; i++, x++)
	utf8_copy_one( (char *)(&DUMB_PIXEL(x, y)), gp_strchrn(str,i));
#else
    for (; x < dumb_xmax && *str; x++, str++)
	dumb_set_pixel(x, y, *str, 5);
#endif
}


TERM_PUBLIC void
DUMB_arrow(
    unsigned int sx, unsigned int sy,
    unsigned int ex, unsigned int ey,
    int head)		/* ignored */
{
    char saved_pen;
    char saved_x;
    char saved_y;

    (void) head;		/* dummy usage avoid compiler warnings */
    saved_pen = dumb_pen;
    saved_x = dumb_x;
    saved_y = dumb_y;

    dumb_pen = '>';
    dumb_x = sx;
    dumb_y = sy;
    DUMB_vector(ex, ey);

    dumb_pen = saved_pen;
    dumb_x = saved_x;
    dumb_y = saved_y;
}


#ifndef NO_DUMB_ENHANCED_SUPPORT
/*
 * The code from here on serves as an example of how to
 * add enhanced text mode support to even a dumb driver.
 */

static TBOOLEAN ENHdumb_opened_string;
static TBOOLEAN ENHdumb_show = TRUE;
static int ENHdumb_overprint = 0;
static TBOOLEAN ENHdumb_widthflag = TRUE;
static unsigned int ENHdumb_xsave, ENHdumb_ysave;
#define ENHdumb_fontsize 1
#define ENHdumb_font ""
static double ENHdumb_base;

TERM_PUBLIC void
ENHdumb_OPEN(
    char *fontname,
    double fontsize, double base,
    TBOOLEAN widthflag, TBOOLEAN showflag,
    int overprint)
{
    /* There are two special cases:
     * overprint = 3 means save current position
     * overprint = 4 means restore saved position
     */
    if (overprint == 3) {
	ENHdumb_xsave = dumb_x;
	ENHdumb_ysave = dumb_y;
	return;
    } else if (overprint == 4) {
	DUMB_move(ENHdumb_xsave, ENHdumb_ysave);
	return;
    }


    if (!ENHdumb_opened_string) {
	ENHdumb_opened_string = TRUE;
	/* Start new text fragment */
	    enhanced_cur_text = &enhanced_text[0];
	/* Scale fractional font height to vertical units of display */
	    ENHdumb_base = base * 2;
	/* Keep track of whether we are supposed to show this string */
	    ENHdumb_show = showflag;
	/* 0/1/2  no overprint / 1st pass / 2nd pass */
	    ENHdumb_overprint = overprint;
	/* widthflag FALSE means do not update text position after printing */
	    ENHdumb_widthflag = widthflag;
	/* Many drivers will need to do something about font selection here */
	    /* but dumb is dumb */
    }
}

TERM_PUBLIC void
ENHdumb_FLUSH()
{
    char *str = enhanced_text;	/* The fragment to print */
    int x = dumb_x;		/* The current position  */
    int y = dumb_y + (int)ENHdumb_base;
    int i, len;

    if (ENHdumb_opened_string) {
	*enhanced_cur_text = '\0';
	len = gp_strlen(str);

	/* print the string fragment, perhaps invisibly */
	/* NB: base expresses offset from current y pos */
	if (ENHdumb_show) {
#ifdef DUMB_UTF8
	    for (i = 0; i < len && x < dumb_xmax; i++, x++)
		utf8_copy_one( (char *)(&DUMB_PIXEL(x, y)), gp_strchrn(str,i));
#else
	    for (; x < dumb_xmax && *str; x++, str++)
		dumb_set_pixel(x, y, *str, 5);
#endif
	}

	if (!ENHdumb_widthflag)
	    /* don't update position */
	    ;
	else if (ENHdumb_overprint == 1)
	    /* First pass of overprint, leave position in center of fragment */
	    dumb_x += len / 2;
	else
	    /* Normal case is to update position to end of fragment */
	    dumb_x += len;

	ENHdumb_opened_string = FALSE;
    }
}

TERM_PUBLIC void
ENHdumb_put_text(unsigned int x, unsigned int y, const char *str)
{
    /* If no enhanced text processing is needed, we can use the plain  */
    /* vanilla put_text() routine instead of this fancy recursive one. */
    if (ignore_enhanced_text || !strpbrk(str, "{}^_@&~")) {
	DUMB_put_text(x,y,str);
	return;
    }

    /* Set up global variables needed by enhanced_recursion() */
    enhanced_fontscale = 1.0;
    ENHdumb_opened_string = FALSE;
    strncpy(enhanced_escape_format,"%c",sizeof(enhanced_escape_format));

    DUMB_move(x,y);

    /* Set the recursion going. We say to keep going until a
     * closing brace, but we don't really expect to find one.
     * If the return value is not the nul-terminator of the
     * string, that can only mean that we did find an unmatched
     * closing brace in the string. We increment past it (else
     * we get stuck in an infinite loop) and try again.
     */
    while (*(str = enhanced_recursion((char *)str, TRUE,
    			ENHdumb_font, ENHdumb_fontsize,
			0.0, TRUE, TRUE, 0))) {
	(term->enhanced_flush)();

	/* I think we can only get here if *str == '}' */
	    enh_err_check(str);

	if (!*++str)
	    break; /* end of string */

	/* else carry on and process the rest of the string */
    }
}
#endif /* NO_DUMB_ENHANCED_SUPPORT */

#endif /* TERM_BODY */

#ifdef TERM_TABLE
TERM_TABLE_START(dumb_driver)
    "dumb", "ascii art for anything that prints text",
    DUMB_XMAX, DUMB_YMAX, 1, 1,
    1, 2, /* account for typical aspect ratio of characters */
    DUMB_options, DUMB_init, DUMB_reset,
    DUMB_text, null_scale, DUMB_graphics, DUMB_move, DUMB_vector,
    DUMB_linetype, DUMB_put_text, null_text_angle,
    null_justify_text, DUMB_point, DUMB_arrow, set_font_null,
    0,				/* pointsize */
    TERM_CAN_MULTIPLOT,
    NULL, NULL, NULL, NULL
#ifdef USE_MOUSE
    , NULL, NULL, NULL, NULL, NULL
#endif
    , NULL, NULL, NULL, NULL
    , NULL /* image */
#ifndef NO_DUMB_ENHANCED_SUPPORT
    , ENHdumb_OPEN, ENHdumb_FLUSH, do_enh_writec
#endif /* NO_DUMB_ENHANCED_SUPPORT */
TERM_TABLE_END(dumb_driver)

#undef LAST_TERM
#define LAST_TERM dumb_driver

#endif /* TERM_TABLE */

#ifdef TERM_HELP
START_HELP(dumb)
"1 dumb",
"?commands set terminal dumb",
"?set terminal dumb",
"?set term dumb",
"?terminal dumb",
"?term dumb",
"?dumb",
" The `dumb` terminal driver plots into a text block using ascii characters.",
" It has an optional size specification and a trailing linefeed flag.",
"",
" Syntax:",
"       set terminal dumb {size <xchars>,<ychars>} {[no]feed}",
"                         {aspect <htic>{,<vtic>}}",
#ifndef NO_DUMB_ENHANCED_SUPPORT
"                         {[no]enhanced}",
#endif
"",
" where <xchars> and <ychars> set the size of the text block. The default is",
" 79 by 24. The last newline is printed only if `feed` is enabled.",
"",
" The `aspect` option can be used to control the aspect ratio of the plot by",
" setting the length of the horizontal and vertical tic marks. Only integer",
" values are allowed. Default is 2,1 -- corresponding to the aspect ratio of",
" common screen fonts.",
"",
" Example:",
"       set term dumb size 60,15 aspect 1",
"       set tics nomirror scale 0.5",
"       plot [-5:6.5] sin(x) with impulse ls -1",
"",
"           1 +-------------------------------------------------+",
"         0.8 +|||++                   ++||||++                 |",
"         0.6 +|||||+                 ++|||||||+  sin(x) +----+ |",
"         0.4 +||||||+               ++|||||||||+               |",
"         0.2 +|||||||+             ++|||||||||||+             +|",
"           0 ++++++++++++++++++++++++++++++++++++++++++++++++++|",
"        -0.2 +        +|||||||||||+              +|||||||||||+ |",
"        -0.4 +         +|||||||||+                +|||||||||+  |",
"        -0.6 +          +|||||||+                  +|||||||+   |",
"        -0.8 +           ++||||+                    ++||||+    |",
"          -1 +---+--------+--------+-------+--------+--------+-+",
"                -4       -2        0       2        4        6  "
END_HELP(dumb)
#endif /* TERM_HELP */
