--- /dev/null
+/* Hello, Emacs, this is -*-C-*-
+ * $Id: hpgl.trm,v 1.22.2.1 2009/03/02 23:57:54 sfeam Exp $
+ */
+
+/* GNUPLOT - hpgl.trm */
+
+/*[
+ * Copyright 1990 - 1993, 1998, 2004
+ *
+ * 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.h.
+ *
+ * This terminal driver supports:
+ * hpgl, hp7550, hp7580b, HP Laserjet III
+ * hp7550 has been replaced by "hpgl 8 eject"
+ * hp7580b has been replaced by "hpgl 4"
+ *
+ * AUTHORS
+ * Colin Kelley, Thomas Williams, Russell Lang
+ *
+ * send your comments or suggestions to (gnuplot-info@lists.sourceforge.net).
+ *
+ */
+
+/*
+ *
+ * MODIFIED for expanded HPGL/2 and PCL utilites
+ * Tom Swiler (tom@silica.mse.ufl.edu)
+ * Modified June 1995 Ian MacPhedran to support newterm format
+ * Modified October 1995 Ian MacPhedran to simplify HPGL terminals
+ * Modified January 96 by David Denholm and Emmanuel Bigler for cp850
+ * and iso international character sets
+ * Modified February 99 by Jeremy Brenes to give PCL5 terminal optional
+ * multi-pen support (6 pen default), a default 34" plotting width for
+ * use with large color plotters such as the HP Designjet 750C,
+ * various alternative plot sizes, and variable fontsizes;
+ * Also decreased the HPGL terminal's fixed fontsize to make it more
+ * reasonable when plots get scaled to 34"
+ * Modified July 99 by Jeremy Brenes to make extended plot area smaller;
+ * added solid/dashed lines option, additional font types, mixed fonts
+ * Modified November 99 by Jeremy Brenes to add a postscript pointtypes
+ * option, special purpose negative pointtypes, and a pointsize function
+ *
+ */
+#define HPGL
+#define PCL
+
+#include "driver.h"
+
+#ifdef TERM_REGISTER
+register_term(hpgl)
+register_term(pcl5)
+#endif /* TERM_REGISTER */
+
+#ifdef TERM_PROTO
+TERM_PUBLIC void HPGL_options __PROTO((void));
+TERM_PUBLIC void HPGL2_options __PROTO((void));
+TERM_PUBLIC void PCL_options __PROTO((void));
+TERM_PUBLIC void HPGL_init __PROTO((void));
+/* TERM_PUBLIC void HPGL2_init __PROTO((void)); */
+TERM_PUBLIC void PCL_init __PROTO((void));
+TERM_PUBLIC void HPGL_graphics __PROTO((void));
+TERM_PUBLIC void HPGL2_graphics __PROTO((void));
+TERM_PUBLIC void PCL_graphics __PROTO((void));
+TERM_PUBLIC void HPGL_text __PROTO((void));
+/* TERM_PUBLIC void HPGL2_text __PROTO((void)); */
+TERM_PUBLIC void PCL_text __PROTO((void));
+TERM_PUBLIC void HPGL_linetype __PROTO((int linetype));
+TERM_PUBLIC void HPGL2_linetype __PROTO((int linetype));
+TERM_PUBLIC void HPGL_put_text __PROTO((unsigned int x, unsigned int y, const char *str));
+TERM_PUBLIC void HPGL2_put_text __PROTO((unsigned int x, unsigned int y, const char *str));
+TERM_PUBLIC void HPGL_move __PROTO((unsigned int x, unsigned int y));
+TERM_PUBLIC void HPGL_vector __PROTO((unsigned int x, unsigned int y));
+TERM_PUBLIC void HPGL2_move __PROTO((unsigned int x, unsigned int y));
+TERM_PUBLIC void HPGL2_vector __PROTO((unsigned int x, unsigned int y));
+TERM_PUBLIC void HPGL2_encode __PROTO((int d));
+TERM_PUBLIC int HPGL_text_angle __PROTO((int ang));
+TERM_PUBLIC int HPGL2_text_angle __PROTO((int ang));
+TERM_PUBLIC void HPGL_reset __PROTO((void));
+/* TERM_PUBLIC void HPGL2_reset __PROTO((void)); */
+TERM_PUBLIC void PCL_reset __PROTO((void));
+TERM_PUBLIC int HPGL2_justify_text __PROTO((enum JUSTIFY just));
+TERM_PUBLIC int HPGL2_set_font __PROTO((const char *font));
+TERM_PUBLIC void HPGL2_point __PROTO((unsigned int x, unsigned int y, int number));
+TERM_PUBLIC void HPGL2_neg_point __PROTO((unsigned int x, unsigned int y, int number));
+TERM_PUBLIC void HPGL2_pointsize __PROTO((double size));
+#define GOT_HPGL_PROTO
+#endif /* TERM_PROTO */
+
+#ifndef TERM_PROTO_ONLY
+#ifdef TERM_BODY
+/*
+ * The maximum plot size, in plotter units.
+ * Note that the actual size of larger plots may be limited by
+ * available printer memory.
+ */
+
+#define HPGL_PUPI 1016 /* Plotter units per inch */
+
+#define HPGL_XMAX_A 10000
+#define HPGL_YMAX_A 7500
+
+#define HPGL_XMAX_B 13000
+#define HPGL_YMAX_B 7500
+
+#define HPGL_XMAX_C 45333
+#define HPGL_YMAX_C 34000
+
+#define HPGL_XMAX_D 52000
+#define HPGL_YMAX_D 34000
+
+#define HPGL_XMAX HPGL_XMAX_A
+#define HPGL_YMAX HPGL_YMAX_A
+
+#define PCL_XMAX HPGL_XMAX_C
+#define PCL_YMAX (HPGL_YMAX_C-60)
+
+/*
+ * Tic sizes
+ */
+
+#define HPGL_VTIC (HPGL_YMAX/70)
+#define HPGL_HTIC (HPGL_YMAX/70)
+
+#define PCL_VTIC ((HPGL_YMAX_C-60)/320)
+#define PCL_HTIC ((HPGL_YMAX_C-60)/320)
+
+/*
+ * Font size for HPGL
+ */
+
+#define HPGL_VCHAR (HPGL_YMAX/100*8/10) /* 0.8% */
+#define HPGL_HCHAR (HPGL_XMAX/100*3/10) /* 0.3% */
+
+/*
+ * Font size for HPGL/2
+ */
+
+#define HPGL2_DEF_POINT 12 /* Height of font */
+
+#define HPGL2_DEF_PITCH (3 * 72 / (HPGL2_DEF_POINT * 2))
+#define HPGL2_VCHAR ((int) HPGL_PUPI * HPGL2_DEF_POINT / 72)
+#define HPGL2_HCHAR (HPGL2_VCHAR * 2 / 3)
+
+/*
+ * Point size for HPGL/2
+ */
+
+static double HPGL2_psize = 1.0; /* Default point size */
+
+/*
+ * Number of available pointtypes for HPGL/2
+ */
+
+#define HPGL2_NUM_NOPSPOINTS 6; /* for nopspoints option */
+#define HPGL2_NUM_PSPOINTS 75; /* for pspoints option */
+
+/*
+ * Control constants
+ */
+
+#define DOWN 0 /* Pen is down */
+#define UP 1 /* Pen is up */
+#define UNKNOWN -10 /* Unknown status for lots of things */
+
+/*
+ * For Polyline Encoded, either use base 64 or base 32.
+ * Save space with base 64, but get 8-bit characters.
+ */
+
+#define HPGL2_BASE64 1
+
+#if HPGL2_BASE64
+#define HPGL2_BITS 6
+#define HPGL2_LOW_OFFS 63
+#define HPGL2_HIGH_OFFS 191
+#define HPGL2_MASK 63
+#else
+#define HPGL2_BITS 5
+#define HPGL2_LOW_OFFS 63
+#define HPGL2_HIGH_OFFS 95
+#define HPGL2_MASK 31
+#endif
+
+/*
+ * Data structures for options
+ */
+
+struct HPGL2_font_str {
+ const char *compare, *name;
+ int symbol_set, spacing;
+ double pitch, height;
+ int posture, stroke_weight, typeface;
+};
+
+struct PCL_mode_str {
+ const char *compare, *name, *command;
+ unsigned int xmax, ymax;
+};
+
+/*
+ * The default font goes first. Although it is the ugliest, the
+ * stick font is probably supported by the most devices.
+ */
+
+static struct HPGL2_font_str GPFAR HPGL2_font_table[] = {
+ {"u$nivers", "univers", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4148},
+ {"s$tick", "stick", 277, 0, HPGL2_DEF_PITCH, 0.0, 0, 0, 48},
+ {"cg_t$imes", "cg_times", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4101},
+ {"z$apf_dingbats", "zapf_dingbats", 364, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4141},
+ {"an$tique_olive", "antique_olive", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4168},
+ {"ar$ial", "arial", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 16602},
+ {"cou$rier", "courier", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4099},
+ {"g$aramond_antigua", "garamond_antigua", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4197},
+ {"l$etter_gothic", "letter_gothic", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4102},
+ {"cg_o$mega", "cg_omega", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4113},
+ {"al$bertus", "albertus", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 1, 4362},
+ {"ti$mes_new_roman", "times_new_roman", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 16901},
+ {"cl$arendon", "clarendon", 277, 1, 0.0, HPGL2_DEF_POINT, 4, 3, 4140},
+ {"cor$onet", "coronet", 277, 1, 0.0, HPGL2_DEF_POINT, 1, 0, 4116},
+ {"m$arigold", "marigold", 277, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 4297},
+ {"tr$uetype_symbols", "truetype_symbols", 621, 1, 0.0, HPGL2_DEF_POINT, 0, 0, 16686},
+ {"w$ingdings", "wingdings", 18540, 1, 0.0, HPGL2_DEF_POINT, 1, 0, 31402}
+};
+
+#define HPGL2_FONTS (sizeof(HPGL2_font_table) / sizeof (struct HPGL2_font_str))
+static struct HPGL2_font_str *HPGL2_font = &HPGL2_font_table[0];
+
+/*
+ * The default mode goes first. Landscape style plots are probably the
+ * most compatable with other HPGL devices.
+ */
+
+static struct PCL_mode_str GPFAR PCL_mode_table[] = {
+ {"l$andscape", "landscape", "\033&l1O", PCL_XMAX, PCL_YMAX},
+ {"p$ortrait", "portrait", "\033&l0O", PCL_YMAX, PCL_XMAX}
+};
+
+#define PCL_MODES (sizeof(PCL_mode_table) / sizeof (struct PCL_mode_str))
+static struct PCL_mode_str *PCL_mode = &PCL_mode_table[0];
+
+/*
+ * Various line types and widths to distinguish data sets in monochrome
+ */
+
+static const char *HPGL2_lt[] = { "", ",2", ",2", ",2", ",2", ",2", ",2", ",2" },
+ *HPGL2_pw[] = { ".24", ".16", ".08"};
+
+#define HPGL2_LINETYPES (sizeof(HPGL2_lt) / sizeof(char *))
+#define HPGL2_PENWIDTHS (sizeof(HPGL2_pw) / sizeof(char *))
+
+/* encoding vector for cp850 , characters 128 (0200) -> 255 (0377) */
+
+static char hpgl_cp_850[128][4] = {
+
+/* 0200 */ "\0164\017",
+/* 0201 */ "\016O\017",
+/* 0202 */ "\016E\017",
+/* 0203 */ "\016@\017",
+/* 0204 */ "\016L\017",
+/* 0205 */ "\016H\017",
+/* 0206 */ "\016T\017",
+/* 0207 */ "\0165\017",
+
+/* 0210 */ "\016A\017",
+/* 0211 */ "\016M\017",
+/* 0212 */ "\016I\017",
+/* 0213 */ "\016]\017",
+/* 0214 */ "\016Q\017",
+/* 0215 */ "\016Y\017",
+/* 0216 */ "\016X\017",
+/* 0217 */ "\016P\017",
+
+/* 0220 */ "\016\134\017",
+/* 0221 */ "\016W\017",
+/* 0222 */ "\016S\017",
+/* 0223 */ "\016B\017",
+/* 0224 */ "\016N\017",
+/* 0225 */ "\016J\017",
+/* 0226 */ "\016C\017",
+/* 0227 */ "\016K\017",
+
+/* 0230 */ "\016o\017",
+/* 0231 */ "\016Z\017",
+/* 0232 */ "\016[\017",
+/* 0233 */ "\016V\017",
+/* 0234 */ "\016;\017",
+/* 0235 */ "\016R\017",
+/* 0236 */ "",
+/* 0237 */ "\016>\017",
+
+/* 0240 */ "\016D\017",
+/* 0241 */ "\016U\017",
+/* 0242 */ "\016F\017",
+/* 0243 */ "\016G\017",
+/* 0244 */ "\0167\017",
+/* 0245 */ "\0166\017",
+/* 0246 */ "\016y\017",
+/* 0247 */ "\016z\017",
+
+/* 0250 */ "\0169\017",
+
+/* 0251 */ "",
+/* 0252 */ "",
+
+/* 0253 */ "\016x\017",
+/* 0254 */ "\016w\017",
+/* 0255 */ "\0168\017",
+/* 0256 */ "\016{\017",
+/* 0257 */ "\016}\017",
+
+/* 0260 */ "",
+/* 0261 */ "",
+/* 0262 */ "",
+/* 0263 */ "",
+/* 0264 */ "",
+
+/* 0265 */ "\016`\017",
+/* 0266 */ "\016\042\017",
+/* 0267 */ "\016!\017",
+
+/* 0270 */ "",
+/* 0271 */ "",
+/* 0272 */ "",
+/* 0273 */ "",
+/* 0274 */ "",
+
+/* 0275 */ "\016?\017",
+/* 0276 */ "\016<\017",
+
+/* 0277 */ "",
+
+/* 0300 */ "",
+/* 0301 */ "",
+/* 0302 */ "",
+/* 0303 */ "",
+/* 0304 */ "",
+/* 0305 */ "",
+
+/* 0306 */ "\016b\017",
+/* 0307 */ "\016a\017",
+
+/* 0310 */ "",
+/* 0311 */ "",
+/* 0312 */ "",
+/* 0313 */ "",
+/* 0314 */ "",
+/* 0315 */ "",
+/* 0316 */ "",
+
+/* 0317 */ "\016:\017",
+
+/* 0320 */ "\016d\017",
+/* 0321 */ "\016c\017",
+/* 0322 */ "\016$\017",
+/* 0323 */ "\016%\017",
+/* 0324 */ "\016#\017",
+
+/* 0325 */ "",
+
+/* 0326 */ "\016e\017",
+/* 0327 */ "\016&\017",
+
+/* 0330 */ "\016'\017",
+
+/* 0331 */ "",
+/* 0332 */ "",
+/* 0333 */ "",
+/* 0334 */ "",
+/* 0335 */ "",
+
+/* 0336 */ "\016f\017",
+/* 0337 */ "",
+
+/* 0340 */ "\016g\017",
+/* 0341 */ "\016^\017",
+/* 0342 */ "\016_\017",
+/* 0343 */ "\016h\017",
+/* 0344 */ "\016j\017",
+/* 0345 */ "\016i\017",
+/* 0346 */ "",
+/* 0347 */ "\016q\017",
+
+/* 0350 */ "\016p\017",
+/* 0351 */ "\016m\017",
+/* 0352 */ "\016.\017",
+/* 0353 */ "\016-\017",
+/* 0354 */ "",
+/* 0355 */ "",
+/* 0356 */ "\0160\017",
+/* 0357 */ "\016(\017",
+
+/* 0360 */ "\016v\017",
+/* 0361 */ "\016~\017",
+/* 0362 */ "",
+/* 0363 */ "",
+/* 0364 */ "",
+/* 0365 */ "\016=\017",
+/* 0366 */ "",
+/* 0367 */ "",
+
+/* 0370 */ "\016z\017",
+/* 0371 */ "\016+\017",
+/* 0372 */ "",
+/* 0373 */ "",
+/* 0374 */ "",
+/* 0375 */ "",
+/* 0376 */ "",
+/* 0377 */ ""
+};
+
+
+/* encoding vector for iso-8859-1 , characters 128 (0200) -> 255 (0377) */
+
+static char hpgl_iso_8859_1[128][4] = {
+
+/* 0200 */ "",
+/* 0201 */ "",
+/* 0202 */ "",
+/* 0203 */ "",
+/* 0204 */ "",
+/* 0205 */ "",
+/* 0206 */ "",
+/* 0207 */ "",
+
+/* 0210 */ "",
+/* 0211 */ "",
+/* 0212 */ "",
+/* 0213 */ "",
+/* 0214 */ "",
+/* 0215 */ "",
+/* 0216 */ "",
+/* 0217 */ "",
+
+/* 0220 */ "",
+/* 0221 */ "\016\017",
+/* 0222 */ "\016\017",
+/* 0223 */ "",
+/* 0224 */ "",
+/* 0225 */ "",
+/* 0226 */ "",
+/* 0227 */ "",
+
+/* 0230 */ "",
+/* 0231 */ "",
+/* 0232 */ "",
+/* 0233 */ "",
+/* 0234 */ "",
+/* 0235 */ "",
+/* 0236 */ "",
+/* 0237 */ "",
+
+/* 0240 */ "",
+/* 0241 */ "\0168\017",
+/* 0242 */ "\0165\017",
+/* 0243 */ "\016;\017",
+/* 0244 */ "\016:\017",
+/* 0245 */ "\016<\017",
+/* 0246 */ "\017|\017",
+/* 0247 */ "\016=\017",
+
+/* 0250 */ "\016+\017",
+/* 0251 */ "",
+/* 0252 */ "\016y\017",
+/* 0253 */ "\016{\017",
+/* 0254 */ "",
+/* 0255 */ "",
+/* 0256 */ "",
+/* 0257 */ "\0160\017",
+
+/* 0260 */ "\016z\017",
+/* 0261 */ "\016~\017",
+/* 0262 */ "",
+/* 0263 */ "",
+/* 0264 */ "",
+/* 0265 */ "",
+/* 0266 */ "",
+/* 0267 */ "",
+
+/* 0270 */ "",
+/* 0271 */ "",
+/* 0272 */ "\016z\017",
+/* 0273 */ "\016}\017",
+/* 0274 */ "\016w\017",
+/* 0275 */ "\016x\017",
+/* 0276 */ "",
+/* 0277 */ "\0169\017",
+
+/* 0300 */ "\016!\017",
+/* 0301 */ "\016`\017",
+/* 0302 */ "\016\042\017",
+/* 0303 */ "\016a\017",
+/* 0304 */ "\016X\017",
+/* 0305 */ "\016P\017",
+/* 0306 */ "\016S\017",
+/* 0307 */ "\0164\017",
+
+/* 0310 */ "\016#\017",
+/* 0311 */ "\016\134\017",
+/* 0312 */ "\016$\017",
+/* 0313 */ "\016%\017",
+/* 0314 */ "\016f\017",
+/* 0315 */ "\016e\017",
+/* 0316 */ "\016\046\017",
+/* 0317 */ "\016'\017",
+
+/* 0320 */ "\016c\017",
+/* 0321 */ "\0166\017",
+/* 0322 */ "\016h\017",
+/* 0323 */ "\016g\017",
+/* 0324 */ "\016_\017",
+/* 0325 */ "\016i\017",
+/* 0326 */ "\016Z\017",
+/* 0327 */ "",
+
+/* 0330 */ "\016R\017",
+/* 0331 */ "\016-\017",
+/* 0332 */ "\016m\017",
+/* 0333 */ "\016.\017",
+/* 0334 */ "\016[\017",
+/* 0335 */ "",
+/* 0336 */ "\016p\017",
+/* 0337 */ "\016^\017",
+
+/* 0340 */ "\016H\017",
+/* 0341 */ "\016D\017",
+/* 0342 */ "\016@\017",
+/* 0343 */ "\016b\017",
+/* 0344 */ "\016L\017",
+/* 0345 */ "\016T\017",
+/* 0346 */ "\016W\017",
+/* 0347 */ "\0165\017",
+
+/* 0350 */ "\016I\017",
+/* 0351 */ "\016E\017",
+/* 0352 */ "\016A\017",
+/* 0353 */ "\016M\017",
+/* 0354 */ "\016Y\017",
+/* 0355 */ "\016U\017",
+/* 0356 */ "\016Q\017",
+/* 0357 */ "\016]\017",
+
+/* 0360 */ "\016d\017",
+/* 0361 */ "\0167\017",
+/* 0362 */ "\016J\017",
+/* 0363 */ "\016F\017",
+/* 0364 */ "\016B\017",
+/* 0365 */ "\016j\017",
+/* 0366 */ "\016N\017",
+/* 0367 */ "",
+
+/* 0370 */ "\016V\017",
+/* 0371 */ "\016K\017",
+/* 0372 */ "\016G\017",
+/* 0373 */ "\016C\017",
+/* 0374 */ "\016O\017",
+/* 0375 */ "",
+/* 0376 */ "\016q\017",
+/* 0377 */ "\016o\017"
+};
+
+
+/*
+ * Static variables to keep track of where we are, etc.
+ */
+
+static int HPGL_ang = 0, HPGL_x = UNKNOWN, HPGL_y = UNKNOWN,
+ HPGL_penstate = UNKNOWN, HPGL_pentype, HPGL2_pentype = UNKNOWN,
+ HPGL2_in_pe, HPGL2_lost;
+
+/*
+ * The subroutines, grouped by function for different versions.
+ */
+
+static int HPGL_numpen, HPGL_eject;
+
+TERM_PUBLIC void
+HPGL_options()
+{
+ HPGL_numpen = 6; /* default to six pens */
+ HPGL_eject = 0; /* default to no eject */
+
+ while (!END_OF_COMMAND) {
+ if (almost_equals(c_token, "eje$ct"))
+ HPGL_eject = 1;
+ else if (isanumber(c_token)) {
+ HPGL_numpen = (int) real(&token[c_token].l_val);
+ if (HPGL_numpen <= 0) {
+ HPGL_numpen = 6;
+ int_error(c_token, "Number of pens must be positive");
+ }
+ } else
+ int_error(c_token, "expecting \"eject\" or number of pens");
+
+ c_token++;
+ }
+
+
+ sprintf(term_options, "%d pens %s", HPGL_numpen,
+ HPGL_eject ? "eject" : "noeject");
+}
+
+static int HPGL2_color = 1, HPGL2_numpen = 6; /* default to 6 pen color */
+static int HPGL2_dashed = 0; /* current dashed linetype */
+static int HPGL2_solid = 1; /* default to solid lines */
+static int HPGL2_font_num = 0; /* font from options */
+static int HPGL2_font_num_current = 0; /* current font */
+static int pspointset = 0; /* default to standard point types */
+static double HPGL2_point_size = HPGL2_DEF_POINT; /* pointsize from options */
+static double HPGL2_point_size_current = 0; /* current pointsize */
+static const char *PCL_dim = "noextended"; /* default plotting dimensions */
+
+
+enum HPGL2_id {
+ HPGL2_MONOCHROME, HPGL2_COLOR, HPGL2_SOLID, HPGL2_DASHED, HPGL2_FONT,
+ HPGL2_SIZE, HPGL2_NOPSPOINTS, HPGL2_PSPOINTS,
+ HPGL2_INVALID
+};
+
+static struct gen_table HPGL2_opts[] =
+{
+ { "mono$chrome", HPGL2_MONOCHROME },
+ { "col$or", HPGL2_COLOR },
+ { "col$our", HPGL2_COLOR },
+ { "sol$id", HPGL2_SOLID },
+ { "das$hed", HPGL2_DASHED },
+ { "f$ont", HPGL2_FONT },
+ { "s$ize", HPGL2_SIZE },
+ { "n$opspoints", HPGL2_NOPSPOINTS },
+ { "p$spoints", HPGL2_PSPOINTS },
+ { NULL, HPGL2_INVALID }
+};
+
+TERM_PUBLIC void
+HPGL2_options()
+{
+ struct termentry *t = term;
+ int i;
+
+ while (!END_OF_COMMAND) {
+ switch(lookup_table(&HPGL2_opts[0],c_token)) {
+ case HPGL2_MONOCHROME:
+ HPGL2_color = 0;
+ c_token++;
+ break;
+ case HPGL2_COLOR:
+ HPGL2_color = 1;
+ c_token++;
+ if (!END_OF_COMMAND && isanumber(c_token)) {
+ HPGL2_numpen = (int) real(&token[c_token].l_val);
+ if (HPGL2_numpen <= 0) {
+ HPGL2_numpen = 6;
+ int_error(c_token, "Number of pens must be a positive");
+ }
+ c_token++;
+ }
+ break;
+ case HPGL2_SOLID:
+ HPGL2_solid = 1;
+ c_token++;
+ break;
+ case HPGL2_DASHED:
+ HPGL2_solid = 0;
+ c_token++;
+ break;
+ case HPGL2_FONT:
+ c_token++;
+ if (!END_OF_COMMAND) {
+ for (i = 0; i < HPGL2_FONTS && !almost_equals(c_token, HPGL2_font_table[i].compare); i++);
+ if (i < HPGL2_FONTS) {
+ HPGL2_font = &HPGL2_font_table[i];
+ HPGL2_font_num = i;
+ HPGL2_font_num_current = HPGL2_font_num;
+ } else
+ int_error(c_token,
+ "expecting font: stick, cg_times, univers, zapf_dingbats, antique_olive,\narial, courier, garamond_antigua, letter_gothic, cg_omega, albertus,\ntimes_new_roman, clarendon, coronet, marigold, truetype_symbols, or wingdings");
+ c_token++;
+ } else
+ int_error(c_token,
+ "expecting font: stick, cg_times, univers, zapf_dingbats, antique_olive,\narial, courier, garamond_antigua, letter_gothic, cg_omega, albertus,\ntimes_new_roman, clarendon, coronet, marigold, truetype_symbols, or wingdings");
+ break;
+ case HPGL2_SIZE:
+ c_token++;
+ if (!END_OF_COMMAND) {
+ if ((HPGL2_point_size = real(&token[c_token].l_val)) > 0.0) {
+ HPGL2_point_size_current = HPGL2_point_size;
+ t->v_char = (int) HPGL_PUPI *HPGL2_point_size / 72;
+ t->h_char = t->v_char * 2 / 3;
+ if (HPGL2_font->spacing)
+ HPGL2_font->height = HPGL2_point_size;
+ else
+ HPGL2_font->pitch = 72 * 3 / (HPGL2_point_size * 2);
+ } else
+ int_error(c_token, "expecting point size: real number");
+ c_token++;
+ } else
+ int_error(c_token, "expecting point size: real number");
+ break;
+ case HPGL2_NOPSPOINTS:
+ c_token++;
+ pspointset = 0;
+ break;
+ case HPGL2_PSPOINTS:
+ c_token++;
+ pspointset = 1;
+ break;
+ case HPGL2_INVALID:
+ c_token++;
+ default:
+ break;
+ }
+ }
+
+ sprintf(term_options+strlen(term_options)," %s %d %s \\\n"
+ " %s %s %f %s",
+ HPGL2_color ? "color" : "monochrome",
+ HPGL2_color == 1 ? HPGL2_numpen : 1,
+ HPGL2_solid ? "solid" : "dashed",
+ HPGL2_font->name,
+ HPGL2_font->spacing ? "height" : "pitch",
+ HPGL2_font->spacing ? HPGL2_font->height : HPGL2_font->pitch,
+ pspointset ? "pspoints" : "nopspoints");
+}
+
+#if 0
+/* Unused for now */
+
+enum PCL_id {
+ PCL_MODE, PCL_EXTENDED, PCL_EXTENDED, PCL_LEGAL, PCL_LETTER,
+ PCL_INVALID
+};
+
+static struct gen_table PCL_opts[] =
+{
+ { "m$ode", PCL_MODE },
+ { "ext$ended", PCL_EXTENDED },
+ { "noext$ended", PCL_NOEXTENDED },
+ { "leg$al", PCL_LEGAL },
+ { "let$ter", PCL_LETTER },
+ { NULL, PCL_INVALID }
+};
+#endif
+
+TERM_PUBLIC void
+PCL_options()
+{
+ int i;
+
+ if (!END_OF_COMMAND && almost_equals(c_token, "m$ode")) {
+ c_token++;
+ if (!END_OF_COMMAND) {
+ for (i = 0; i < PCL_MODES && !almost_equals(c_token, PCL_mode_table[i].compare); i++);
+ if (i < PCL_MODES)
+ PCL_mode = &PCL_mode_table[i];
+ else
+ int_error(c_token, "expecting mode: portrait or landscape");
+ c_token++;
+ } else
+ int_error(c_token, "expecting mode: portrait or landscape");
+ }
+ if (!END_OF_COMMAND && almost_equals(c_token, "ext$ended")) {
+ PCL_mode->xmax = (HPGL_XMAX_D);
+ PCL_mode->ymax = (HPGL_YMAX_D - 60);
+ PCL_dim = "extended";
+ c_token++;
+ } else if (!END_OF_COMMAND && almost_equals(c_token, "noext$ended")) {
+ PCL_mode->xmax = (HPGL_XMAX_C);
+ PCL_mode->ymax = (HPGL_YMAX_C - 60);
+ PCL_dim = "noextended";
+ c_token++;
+ } else if (!END_OF_COMMAND && almost_equals(c_token, "leg$al")) {
+ PCL_mode->xmax = (HPGL_XMAX_B);
+ PCL_mode->ymax = (HPGL_YMAX_B - 60);
+ PCL_dim = "legal";
+ c_token++;
+ } else if (!END_OF_COMMAND && almost_equals(c_token, "let$ter")) {
+ PCL_mode->xmax = (HPGL_XMAX_A);
+ PCL_mode->ymax = (HPGL_YMAX_A - 60);
+ PCL_dim = "letter";
+ c_token++;
+ }
+ sprintf(term_options, "%s %s", PCL_mode->name, PCL_dim);
+ HPGL2_options();
+}
+
+TERM_PUBLIC void
+HPGL_init()
+{
+}
+
+/* void HPGL2_init ()
+{
+} */
+
+TERM_PUBLIC void
+PCL_init()
+{
+ struct termentry *t = term;
+/*
+ * Reset printer, set to one copy, orientation of user's choice.
+ * Make the change to the new orientation all at once.
+ */
+ fprintf(gpoutfile, "\033E\033&l1X%s\n", PCL_mode->command);
+ t->xmax = PCL_mode->xmax;
+ t->ymax = PCL_mode->ymax;
+/*
+ * Enter HPGL/2 graphics mode
+ * Necessary here to keep the first DI0,1DI1,0 orientation command from being
+ * printed as literal text on the page for some devices. Hopefully this
+ * workaround has no bad consequences elsewhere; omit this line if it does.
+ */
+ fputs("\033%0B", gpoutfile);
+}
+
+TERM_PUBLIC void
+HPGL_graphics()
+{
+ fputs("\033.Y\n\033.I81;;17:\033.N;19:\033.M500:\n", gpoutfile);
+/* 1
+ 1. enable eavesdropping
+*/
+ fprintf(gpoutfile,
+ "IN;%s\nSC0,%d,0,%d;\nSR%f,%f;\n",
+ ((encoding == S_ENC_CP850) || (encoding == S_ENC_ISO8859_1)) ?
+ "CA7;" : "",
+ HPGL_XMAX, HPGL_YMAX, ((double) (HPGL_HCHAR) * 200 / 3 / HPGL_XMAX), ((double) (HPGL_VCHAR) * 100 / 2 / HPGL_YMAX));
+/* 1 2 3
+ 1. reset to power-up defaults
+ 2. set SCaling
+ 3. set character size
+*/
+ HPGL_ang = 0;
+}
+
+TERM_PUBLIC void
+HPGL2_graphics()
+{
+/*
+ * IN - Initialize
+ * SP - Select pen
+ * SD - Set default font
+ */
+ fprintf(gpoutfile, "INSP1SD1,%d,2,%d,", HPGL2_font->symbol_set, HPGL2_font->spacing);
+ if (HPGL2_font->spacing)
+ fprintf(gpoutfile, "4,%f,", HPGL2_font->height);
+ else
+ fprintf(gpoutfile, "3,%f,", HPGL2_font->pitch);
+ fprintf(gpoutfile, "5,%d,6,%d,7,%d;SS;\n", HPGL2_font->posture, HPGL2_font->stroke_weight, HPGL2_font->typeface);
+/*
+ * Add a set of user-defined dashed linetypes if the dashed option is
+ * selected. Of course, the UL's below can be edited to user preference.
+ */
+ if (HPGL2_solid == 0) {
+ fputs("\
+UL1,100;\n\
+UL2,8,8,9,8,8,9,8,8,9,8,8,9;\n\
+UL3,6,6,6,7,6,6,6,7,6,6,6,7,6,6,6,7;\n\
+UL4,5,5,5,10,5,5,5,10,5,5,5,10;\n\
+UL5,5,5,5,5,5,8,5,5,5,5,5,8,5,5,5,5,5,9;\n\
+UL6,8,8,0,9,8,8,0,9,8,8,0,9;\n\
+UL7,4,4,4,4,0,4,4,4,4,4,0,4,4,4,4,4,0,4;\n\
+UL8,6,6,6,6,6,6,0,6,6,6,6,6,6,6,0,6;\n",
+ gpoutfile);
+ }
+/*
+ * Control variables
+ */
+ HPGL_ang = 0; /* Horizontal */
+ HPGL2_in_pe = FALSE; /* Not in PE command */
+ HPGL2_lost = TRUE; /* Pen position is unknown */
+ HPGL_penstate = UP; /* Pen is up */
+}
+
+TERM_PUBLIC void
+PCL_graphics()
+{
+/*
+ * Enter HPGL/2 graphics mode
+ */
+ fputs("\033%0B", gpoutfile);
+ HPGL2_graphics();
+}
+
+TERM_PUBLIC void
+HPGL_text()
+{
+ if (HPGL_eject == 0) {
+ fputs("PUSP0;\033.Z\n\0", gpoutfile);
+/* 1 2 3
+ 1. pen up
+ 2. park pen
+ 3. disable eavesdropping
+*/
+ } else {
+ fputs("PUSP0;PG;\033.Z\n\0", gpoutfile);
+/* 1 2 3 4
+ 1. pen up
+ 2. park pen
+ 3. page eject
+ 4. disable eavesdropping
+*/
+ }
+ HPGL_penstate = UP;
+}
+
+#if 0 /* not used */
+void
+HPGL2_text()
+{
+/*
+ * If in Polyline Encoded command, leave Polyline Encoded command
+ */
+ if (HPGL2_in_pe) {
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+/*
+ * Pen up, park pen
+ */
+ fputs("PUSP0;", gpoutfile);
+ HPGL_penstate = UP;
+}
+#endif
+
+TERM_PUBLIC void
+PCL_text()
+{
+ if (HPGL2_in_pe) {
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+/*
+ * Go into PCL mode and eject the page
+ */
+ fputs("\033%1A\033&l0H\n\0", gpoutfile);
+}
+
+TERM_PUBLIC void
+HPGL_linetype(int linetype)
+{
+ if (linetype < -2)
+ linetype = LT_BLACK;
+/* allow for set number of pens */
+ linetype = (linetype + 2) % HPGL_numpen + 1;
+/* only select pen if necessary */
+ if (HPGL_pentype != linetype) {
+ fprintf(gpoutfile, "PU;\nSP%d;\n", linetype);
+ HPGL_pentype = linetype;
+ HPGL_penstate = UP;
+ }
+}
+
+TERM_PUBLIC void
+HPGL2_linetype(int linetype)
+{
+/*
+ * If in Polyline Encoded command, leave Polyline Encoded command
+ */
+ if (HPGL2_in_pe) {
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+/* allow for set number of pens for color displays */
+ if (HPGL2_color == 1) {
+ if (linetype >= 0) {
+ if (HPGL2_solid == 0)
+ HPGL2_dashed = linetype % HPGL2_LINETYPES + 1;
+ linetype = (linetype + 2) % HPGL2_numpen + 1;
+ }
+/* only select pen if necessary */
+ if (linetype != HPGL2_pentype) {
+ if (linetype >= 0) {
+ if (HPGL2_solid == 0) {
+ fprintf(gpoutfile, "PU;\nSP%d;\nLT%d;", linetype, HPGL2_dashed);
+ } else
+ fprintf(gpoutfile, "PU;\nSP%d;\nLT;", linetype);
+/* Borders and Tics */
+ } else if (linetype == LT_BLACK) {
+ fprintf(gpoutfile, "PU;\nSP1;\nPW.2LT");
+/* Axes and Grids */
+ } else if (linetype == LT_AXIS)
+ fprintf(gpoutfile, "PU;\nSP1;\nPW.2LT1,.25");
+ HPGL_penstate = UP;
+ HPGL2_pentype = linetype;
+ }
+/* allow for lots of linetypes for monochrome displays */
+ } else {
+ if (linetype >= 0) {
+ if (HPGL2_solid == 0)
+ HPGL2_dashed = linetype % HPGL2_LINETYPES + 1;
+ linetype = linetype % (HPGL2_LINETYPES * HPGL2_PENWIDTHS);
+ }
+/* only select pen if necessary */
+ if (linetype != HPGL2_pentype) {
+ if (linetype >= 0) {
+ if (HPGL2_solid == 0) {
+ fprintf(gpoutfile, "PW%sLT%d%s", HPGL2_pw[linetype / HPGL2_LINETYPES], HPGL2_dashed,
+ HPGL2_lt[linetype % HPGL2_LINETYPES]);
+ } else
+ fprintf(gpoutfile, "PW%sLT", HPGL2_pw[linetype / HPGL2_LINETYPES]);
+/* Borders and Tics */
+ } else if (linetype == LT_BLACK) {
+ fprintf(gpoutfile, "PW.2LT");
+/* Axes and Grids */
+ } else if (linetype == LT_AXIS)
+ fprintf(gpoutfile, "PW.1LT1,.25");
+ HPGL2_pentype = linetype;
+ }
+ }
+}
+
+TERM_PUBLIC void
+HPGL_put_text(unsigned int x, unsigned int y, const char *str)
+{
+ if (HPGL_ang == 1)
+ HPGL_move(x + HPGL_VCHAR / 4, y);
+ else
+ HPGL_move(x, y - HPGL_VCHAR / 4);
+ if (encoding == S_ENC_CP850) {
+ unsigned char *s;
+ fputs("LB", gpoutfile);
+ for (s = (unsigned char *) str; *s; ++s)
+ if (*s >= 128 && hpgl_cp_850[*s - 128][0])
+ fputs(hpgl_cp_850[*s - 128], gpoutfile);
+ else
+ putc(*s, gpoutfile);
+ fputs("\003\n", gpoutfile);
+ } else if (encoding == S_ENC_ISO8859_1) {
+ unsigned char *s;
+ fputs("LB", gpoutfile);
+ for (s = (unsigned char *) str; *s; ++s)
+ if (*s >= 128 && hpgl_iso_8859_1[*s - 128][0])
+ fputs(hpgl_iso_8859_1[*s - 128], gpoutfile);
+ else
+ putc(*s, gpoutfile);
+ fputs("\003\n", gpoutfile);
+ } else
+ fprintf(gpoutfile, "LB%s\003\n", str);
+}
+
+TERM_PUBLIC void
+HPGL2_put_text(unsigned int x, unsigned int y, const char *str)
+{
+ struct termentry *t = term;
+/*
+ * Position the pen
+ */
+ if (HPGL_ang == 1)
+ HPGL2_move(x + t->v_char / 4, y);
+ else
+ HPGL2_move(x, y - t->v_char / 4);
+/*
+ * If in Polyline Encoded command, leave Polyline Encoded command
+ */
+ if (HPGL2_in_pe) {
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+/*
+ * Print the text string
+ */
+ fprintf(gpoutfile, "LB%s\003\n", str);
+ HPGL2_lost = 1;
+}
+
+/*
+ * Some early HPGL plotters (e.g. HP7220C) require the
+ * Pen Up/Down and Pen (move) Absolute commands to be separate.
+ */
+
+TERM_PUBLIC void
+HPGL_move(unsigned int x, unsigned int y)
+{
+ if (HPGL_x != x || HPGL_y != y) { /* only move if necessary */
+ fprintf(gpoutfile, "PU;PA%d,%d;\n", x, y);
+ HPGL_penstate = UP;
+ HPGL_x = x;
+ HPGL_y = y;
+ }
+}
+
+TERM_PUBLIC void
+HPGL_vector(unsigned int x, unsigned int y)
+{
+ if (HPGL_penstate != DOWN) {
+ fprintf(gpoutfile, "PD;PA%d,%d;\n", x, y);
+ HPGL_penstate = DOWN;
+ } else
+ fprintf(gpoutfile, "PA%d,%d;\n", x, y);
+ HPGL_x = x;
+ HPGL_y = y;
+}
+
+TERM_PUBLIC void
+HPGL2_move(unsigned int x, unsigned int y)
+{
+ int dx, dy;
+ if (HPGL2_in_pe) {
+ dx = x - HPGL_x;
+ dy = y - HPGL_y;
+ fputs("<", gpoutfile);
+ } else {
+#if HPGL2_BASE64
+ fputs("PE<", gpoutfile);
+#else
+ fputs("PE7<", gpoutfile);
+#endif
+ if (HPGL2_lost) {
+ dx = x;
+ dy = y;
+ HPGL2_lost = 0;
+ fputs("=", gpoutfile);
+ } else {
+ dx = x - HPGL_x;
+ dy = y - HPGL_y;
+ }
+ HPGL2_in_pe = 1;
+ }
+#if HPGL2_EXPLICIT_PD
+ if (HPGL_penstate == DOWN)
+ HPGL_penstate = UP;
+#endif
+ HPGL2_encode(dx);
+ HPGL2_encode(dy);
+ fputs("\n", gpoutfile);
+ HPGL_x = x;
+ HPGL_y = y;
+}
+
+TERM_PUBLIC void
+HPGL2_vector(unsigned int x, unsigned int y)
+{
+ int dx, dy;
+ if (HPGL2_in_pe) {
+ dx = x - HPGL_x;
+ dy = y - HPGL_y;
+ } else {
+#if HPGL2_BASE64
+ fputs("PE", gpoutfile);
+#else
+ fputs("PE7", gpoutfile);
+#endif
+ if (HPGL2_lost) {
+ dx = x;
+ dy = y;
+ HPGL2_lost = 0;
+ fputs("=", gpoutfile);
+ } else {
+ dx = x - HPGL_x;
+ dy = y - HPGL_y;
+ }
+ HPGL2_in_pe = 1;
+ }
+#if HPGL2_EXPLICIT_PD
+/*
+ * Put the pen down in the current position,
+ * relative vector of 0,0.
+ */
+ if (HPGL_penstate == UP) {
+ fputc((char) HPGL2_HIGH_OFFS, gpoutfile);
+ fputc((char) HPGL2_HIGH_OFFS, gpoutfile);
+ HPGL_penstate = DOWN;
+ }
+#endif
+ HPGL2_encode(dx);
+ HPGL2_encode(dy);
+ fputs("\n", gpoutfile);
+ HPGL_x = x;
+ HPGL_y = y;
+}
+
+/*
+ * Routine to encode position in base 32 or base 64 characters
+ */
+
+TERM_PUBLIC void
+HPGL2_encode(int d)
+{
+ int c;
+
+ if ((d <<= 1) < 0)
+ d = 1 - d;
+ do {
+ c = d & HPGL2_MASK;
+ d >>= HPGL2_BITS;
+ if (d > 0)
+ fputc((char) (c + HPGL2_LOW_OFFS), gpoutfile);
+ else
+ fputc((char) (c + HPGL2_HIGH_OFFS), gpoutfile);
+ } while (d > 0);
+}
+
+TERM_PUBLIC int
+HPGL_text_angle(int ang)
+{
+ if (ang == -90 || ang == 270)
+ HPGL_ang = -1;
+ else
+ HPGL_ang = (ang ? 1 : 0);
+
+ if (HPGL_ang == 0) /* Horizontal */
+ fputs("DI1,0;\n", gpoutfile);
+ else if (HPGL_ang == -1) /* Vertical Down */
+ fputs("DI0,-1;\n", gpoutfile);
+ else /* Vertical Up */
+ fputs("DI0,1;\n", gpoutfile);
+ return TRUE;
+}
+
+TERM_PUBLIC int
+HPGL2_text_angle(int ang)
+{
+/*
+ * If in Polyline Encoded command, leave Polyline Encoded command
+ */
+ if (ang == -90 || ang == 270)
+ HPGL_ang = -1;
+ else
+ HPGL_ang = (ang ? 1 : 0);
+
+ if (HPGL2_in_pe) {
+ fputs(";", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+ if (HPGL_ang == 1) /* Vertical Up */
+ fputs("DI0,1", gpoutfile);
+ else if (HPGL_ang == -1) /* Vertical Down */
+ fputs("DI0,-1", gpoutfile);
+ else /* Horizontal */
+ fputs("DI1,0", gpoutfile);
+ return TRUE;
+}
+
+TERM_PUBLIC void
+HPGL_reset()
+{
+/*
+ * do nothing
+ */
+}
+
+#if 0
+void
+HPGL2_reset()
+{
+/*
+ * Park the pen
+ * Advance a page
+ * End with ";"
+ */
+ fputs("SP0PG;\n", gpoutfile);
+}
+
+#endif
+
+TERM_PUBLIC void
+PCL_reset()
+{
+/*
+ * Return to PCL mode
+ * Printer reset (conditional eject)
+ */
+ fputs("\033%0A\033E\n", gpoutfile);
+}
+
+TERM_PUBLIC int
+HPGL2_justify_text(enum JUSTIFY just)
+{
+/*
+ * If in Polyline Encoded command, leave Polyline Encoded command
+ */
+ if (HPGL2_in_pe) {
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+ switch (just) {
+ case LEFT:
+ fputs("LO1", gpoutfile);
+ break;
+ case CENTRE:
+ fputs("LO4", gpoutfile);
+ break;
+ case RIGHT:
+ fputs("LO7", gpoutfile);
+ break;
+ default:
+ return 0;
+ }
+ return 1;
+}
+
+TERM_PUBLIC int
+HPGL2_set_font(const char *font)
+{
+ struct termentry *t = term;
+ char name[MAX_ID_LEN + 1];
+ int i, sep, int_size, sep2;
+ double size;
+/*
+ * If in Polyline Encoded command, leave Polyline Encoded command
+ */
+ if (HPGL2_in_pe) {
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ }
+/* determine font, use default from options if invalid */
+ sep = strcspn(font, ",");
+ strncpy(name, font, sep);
+ name[sep] = NUL;
+ for (i = 0; i < HPGL2_FONTS; i++) {
+ sep2 = strcspn(HPGL2_font_table[i].compare, "$");
+ if (strncmp(name, HPGL2_font_table[i].compare, sep2) == 0)
+ break;
+ }
+ if (i >= HPGL2_FONTS)
+ i = HPGL2_font_num;
+/* determine font size, use default from options if invalid */
+ int_size = 0;
+ sscanf(&(font[sep + 1]), "%d", &int_size);
+ if (int_size > 0) {
+ size = int_size;
+ } else
+ size = HPGL2_point_size;
+/* apply font changes only if necessary */
+ if (size == HPGL2_point_size_current && i == HPGL2_font_num_current)
+ return FALSE;
+ HPGL2_font = &HPGL2_font_table[i];
+ HPGL2_font_num_current = i;
+ HPGL2_point_size_current = size;
+ t->v_char = (int) HPGL_PUPI *HPGL2_point_size_current / 72;
+ t->h_char = t->v_char * 2 / 3;
+ fprintf(gpoutfile, "SD1,%d,2,%d,", HPGL2_font->symbol_set, HPGL2_font->spacing);
+ if (HPGL2_font->spacing) {
+ HPGL2_font->height = HPGL2_point_size_current;
+ fprintf(gpoutfile, "4,%f,", HPGL2_font->height);
+ } else {
+ HPGL2_font->pitch = 72 * 3 / (HPGL2_point_size_current * 2);
+ fprintf(gpoutfile, "3,%f,", HPGL2_font->pitch);
+ }
+ fprintf(gpoutfile, "5,%d,6,%d,7,%d;SS;\n", HPGL2_font->posture, HPGL2_font->stroke_weight, HPGL2_font->typeface);
+ return TRUE;
+}
+
+TERM_PUBLIC void
+HPGL2_point(unsigned int x, unsigned int y, int number)
+{
+ int htic, vtic;
+ if (pspointset) { /* postscript style points */
+ if (number < 0) {
+ HPGL2_neg_point(x, y, number);
+ } else {
+ htic = (int) (HPGL2_psize * PCL_HTIC / 2);
+ vtic = (int) (HPGL2_psize * PCL_VTIC / 2);
+ number %= HPGL2_NUM_PSPOINTS;
+ switch (number) {
+ case 0: /* plus */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x, y + vtic);
+ break;
+ case 1: /* X */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_move(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ break;
+ case 2: /* star */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_move(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ break;
+ case 3: /* hollow square 1 */
+ HPGL2_move(x - (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 4: /* solid square 1 */
+ HPGL2_move(x - (3 * htic / 4), y - (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%.2f,%.2f;EP;\n", ((double) x + (3 * htic / 4)), ((double) y + (3 * vtic / 4)));
+ break;
+ case 5: /* hollow circle 1 */
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case 6: /* solid circle 1 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case 7: /* hollow triangle 1 */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 8: /* solid triangle 1 */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 9: /* hollow triangle 2 */
+ HPGL2_move(x, y - (3 * vtic / 4));
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 10: /* solid triangle 2 */
+ HPGL2_move(x, y - (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 11: /* hollow diamond 1 */
+ HPGL2_move(x - (3 * htic / 4), y);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y);
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 12: /* solid diamond 1 */
+ HPGL2_move(x - (3 * htic / 4), y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y);
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 13: /* hollow pentagon 1 */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x - (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 14: /* solid pentagon */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x - (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 15: /* hollow circle 2 */
+ HPGL2_move(x, y + vtic);
+ HPGL2_vector(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%d;\n", htic);
+ break;
+ case 16: /* semisolid circle 1 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,0,90;EP;EW%d,90,270;\n", htic, htic);
+ break;
+ case 17: /* semisolid circle 2 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,90,90;EP;EW%d,180,270;\n", htic, htic);
+ break;
+ case 18: /* semisolid circle 3 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,0,180;EP;EW%d,180,180;\n", htic, htic);
+ break;
+ case 19: /* semisolid circle 4 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,180,90;EP;EW%d,270,270;\n", htic, htic);
+ break;
+ case 20: /* semisolid circle 5 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,0,90;EP;EW%d,90,90;WG%d,180,90;EP;EW%d,270,90;\n", htic, htic, htic, htic);
+ break;
+ case 21: /* semisolid circle 6 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,90,180;EP;EW%d,270,180;\n", htic, htic);
+ break;
+ case 22: /* semisolid circle 7 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,0,270;EP;EW%d,270,90;\n", htic, htic);
+ break;
+ case 23: /* semisolid circle 8 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,270,90;EP;EW%d,0,270;\n", htic, htic);
+ break;
+ case 24: /* semisolid circle 9 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,270,180;EP;EW%d,90,180;\n", htic, htic);
+ break;
+ case 25: /* semisolid circle 10 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,90,90;EP;EW%d,180,90;WG%d,270,90;EP;EW%d,0,90;\n", htic, htic, htic, htic);
+ break;
+ case 26: /* semisolid circle 11 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,270,270;EP;EW%d,180,90;\n", htic, htic);
+ break;
+ case 27: /* semisolid circle 12 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,180,180;EP;EW%d,0,180;\n", htic, htic);
+ break;
+ case 28: /* semisolid circle 13 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,180,270;EP;EW%d,90,90;\n", htic, htic);
+ break;
+ case 29: /* semisolid circle 14 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,90,270;EP;EW%d,0,90;\n", htic, htic);
+ break;
+ case 30: /* solid circle 2 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%d,0,360;EP;\n", htic);
+ break;
+ case 31: /* hollow square 2 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_move(x, y + vtic);
+ HPGL2_vector(x, y);
+ break;
+ case 32: /* semisolid square 1 */
+ HPGL2_move(x, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 33: /* semisolid square 2 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y + vtic);
+ break;
+ case 34: /* semisolid square 3 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 35: /* semisolid square 4 */
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y);
+ break;
+ case 36: /* semisolid square 5 */
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 37: /* semisolid square 6 */
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y + vtic);
+ break;
+ case 38: /* semisolid square 7 */
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 39: /* semisolid square 8 */
+ HPGL2_move(x + htic, y);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y);
+ break;
+ case 40: /* semisolid square 9 */
+ HPGL2_move(x, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 41: /* semisolid square 10 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_move(x + htic, y);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y + vtic);
+ HPGL2_move(x, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y);
+ break;
+ case 42: /* semisolid square 11 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ HPGL2_move(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y + vtic);
+ break;
+ case 43: /* semisolid square 12 */
+ HPGL2_move(x + htic, y);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y);
+ break;
+ case 44: /* semisolid square 13 */
+ HPGL2_move(x, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 45: /* semisolid square 14 */
+ HPGL2_move(x + htic, y);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y);
+ HPGL2_move(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x, y + vtic);
+ break;
+ case 46: /* solid square 2 */
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "RA%d,%d;EP;\n", x + htic, y + vtic);
+ break;
+ case 47: /* hollow diamond 2 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_move(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y);
+ break;
+ case 48: /* semisolid diamond 1 */
+ HPGL2_move(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 49: /* semisolid diamond 2 */
+ HPGL2_move(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 50: /* semisolid diamond 3 */
+ HPGL2_move(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 51: /* semisolid diamond 4 */
+ HPGL2_move(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 52: /* semisolid diamond 5 */
+ HPGL2_move(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ HPGL2_move(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 53: /* semisolid diamond 6 */
+ HPGL2_move(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 54: /* semisolid diamond 7 */
+ HPGL2_move(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 55: /* semisolid diamond 8 */
+ HPGL2_move(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 56: /* semisolid diamond 9 */
+ HPGL2_move(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 57: /* semisolid diamond 10 */
+ HPGL2_move(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ HPGL2_move(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 58: /* semisolid diamond 11 */
+ HPGL2_move(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 59: /* semisolid diamond 12 */
+ HPGL2_move(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 60: /* semisolid diamond 13 */
+ HPGL2_move(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y);
+ HPGL2_vector(x - (htic / 2), y - (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 61: /* semisolid diamond 14 */
+ HPGL2_move(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y);
+ HPGL2_vector(x - (htic / 2), y + (vtic / 2));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 62: /* solid diamond 2 */
+ HPGL2_move(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FP;EP;\n");
+ break;
+ case 63: /* hollow square 3 */
+ HPGL2_move(x - (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y - (3 * vtic / 4));
+ break;
+ case 64: /* hollow circle 3 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case 65: /* hollow triangle 3 */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ break;
+ case 66: /* hollow triangle 4 */
+ HPGL2_move(x, y - (3 * vtic / 4));
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ break;
+ case 67: /* hollow diamond 3 */
+ HPGL2_move(x - (3 * htic / 4), y);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y);
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y);
+ break;
+ case 68: /* hollow pentagon 2 */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x - (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ break;
+ case 69: /* opaque square */
+ HPGL2_move(x - htic, y - vtic);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "FT10,30;RA%d,%d;EP;FT;\n", x + (3 * htic / 4), y + (3 * vtic / 4));
+ break;
+ case 70: /* opaque circle */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "FT10,30;WG%.2f,0,360;EP;FT;\n", ((double) 3 * (htic) / 4));
+ break;
+ case 71: /* opaque triangle 1 */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y - (3 * vtic / 8));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FT10,30;FP;EP;FT;\n");
+ break;
+ case 72: /* opaque triangle 2 */
+ HPGL2_move(x, y - (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x + (3 * sqrt(3) * htic / 8), y + (3 * vtic / 8));
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FT10,30;FP;EP;FT;\n");
+ break;
+ case 73: /* opaque diamond */
+ HPGL2_move(x - (3 * htic / 4), y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y);
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FT10,30;FP;EP;FT;\n");
+ break;
+ case 74: /* opaque pentagon */
+ HPGL2_move(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM0;\n");
+ HPGL2_vector(x - (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x - (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (sin(.2 * acos(-1)) * 3 * htic / 4), y - (cos(.2 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x + (cos(.1 * acos(-1)) * 3 * htic / 4), y + (sin(.1 * acos(-1)) * 3 * vtic / 4));
+ HPGL2_vector(x, y + (3 * vtic / 4));
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "PM2;FT10,30;FP;EP;FT;\n");
+ break;
+ }
+ }
+ } else { /* default style points */
+ if (number < 0) {
+ HPGL2_neg_point(x, y, number);
+ } else {
+ htic = (int) (HPGL2_psize * PCL_HTIC / 2);
+ vtic = (int) (HPGL2_psize * PCL_VTIC / 2);
+ number %= HPGL2_NUM_NOPSPOINTS;
+ switch (number) {
+ case 0: /* diamond */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x + htic, y);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_vector(x - htic, y);
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 1: /* plus */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x, y + vtic);
+ break;
+ case 2: /* box */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 3: /* X */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_move(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ break;
+ case 4: /* triangle */
+ HPGL2_move(x, y + (4 * vtic / 3));
+ HPGL2_vector(x - (4 * htic / 3), y - (2 * vtic / 3));
+ HPGL2_vector(x + (4 * htic / 3), y - (2 * vtic / 3));
+ HPGL2_vector(x, y + (4 * vtic / 3));
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ case 5: /* star */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - htic, y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_move(x - htic, y + vtic);
+ HPGL2_vector(x - htic, y + vtic);
+ HPGL2_vector(x + htic, y - vtic);
+ break;
+ }
+ }
+ }
+}
+
+/*
+ * This is for special purpose negative point types. If they are not needed,
+ * they should be safely ignorable, but the special pointypes can be omitted
+ * if necessary, leaving only the dot (which is -1).
+ */
+
+TERM_PUBLIC void
+HPGL2_neg_point(unsigned int x, unsigned int y, int number)
+{
+ int htic, vtic;
+ htic = (int) (HPGL2_psize * PCL_HTIC / 2);
+ vtic = (int) (HPGL2_psize * PCL_VTIC / 2);
+ switch (number) {
+ case -20: /* well 18 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x + htic, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -19: /* well 17 */
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (vtic / 2));
+ HPGL2_move(x, y + (vtic / 2));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x - (htic / 4), y - (3 * vtic / 4));
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x + (htic / 4), y - (3 * vtic / 4));
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) (htic) / 2));
+ break;
+ case -18: /* well 16 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -17: /* well 15 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + htic, y + vtic);
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "EW%.2f,0,180;\n", ((double) 3 * (htic) / 4));
+ fprintf(gpoutfile, "WG%.2f,180,180;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -16: /* well 14 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + htic, y + vtic);
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -15: /* well 13 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + htic, y + vtic);
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -14: /* well 12 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + htic, y + vtic);
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -13: /* well 11 */
+ HPGL2_move(x - htic, y - vtic);
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + htic, y + vtic);
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -12: /* well 10 */
+ HPGL2_move(x + (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "EW%.2f,0,180;\n", ((double) 3 * (htic) / 4));
+ fprintf(gpoutfile, "WG%.2f,180,180;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -11: /* well 9 */
+ HPGL2_move(x + (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -10: /* well 8 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "EW%.2f,0,180;\n", ((double) 3 * (htic) / 4));
+ fprintf(gpoutfile, "WG%.2f,180,180;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -9: /* well 7 */
+ HPGL2_move(x - (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "EW%.2f,0,180;\n", ((double) 3 * (htic) / 4));
+ fprintf(gpoutfile, "WG%.2f,180,180;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -8: /* well 6 */
+ HPGL2_move(x + (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -7: /* well 5 */
+ HPGL2_move(x - (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -6: /* well 4 */
+ HPGL2_move(x - (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y - (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y - (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x + (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x + (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - (sqrt(2) * htic / 2), y + (sqrt(2) * vtic / 2));
+ HPGL2_vector(x - (3 * sqrt(2) * htic / 8), y + (3 * sqrt(2) * vtic / 8));
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -5: /* well 3 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "WG%.2f,0,360;EP;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -4: /* well 2 */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -3: /* well 1 */
+ HPGL2_move(x, y);
+ fputs(";\n", gpoutfile);
+ HPGL2_in_pe = 0;
+ fprintf(gpoutfile, "CI%.2f;\n", ((double) 3 * (htic) / 4));
+ break;
+ case -2: /* v box */
+ HPGL2_move(x - htic, y);
+ HPGL2_vector(x - (3 * htic / 4), y);
+ HPGL2_move(x + (3 * htic / 4), y);
+ HPGL2_vector(x + htic, y);
+ HPGL2_move(x, y - vtic);
+ HPGL2_vector(x, y - (3 * vtic / 4));
+ HPGL2_move(x, y + (3 * vtic / 4));
+ HPGL2_vector(x, y + vtic);
+ HPGL2_move(x - (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_vector(x + (3 * htic / 4), y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y + (3 * vtic / 4));
+ HPGL2_vector(x - (3 * htic / 4), y - (3 * vtic / 4));
+ HPGL2_move(x - (htic / 2), y + (vtic / 2));
+ HPGL2_vector(x, y - (vtic / 2));
+ HPGL2_vector(x + (htic / 2), y + (vtic / 2));
+ break;
+ default: /* dot */
+ HPGL2_move(x, y);
+ HPGL2_vector(x, y);
+ break;
+ return;
+ }
+}
+
+TERM_PUBLIC void
+HPGL2_pointsize(double size)
+{
+ HPGL2_psize = (size >= 0 ? size : 1);
+}
+
+#endif /* TERM_BODY */
+
+#ifdef TERM_TABLE
+TERM_TABLE_START(hpgl_driver)
+ "hpgl", "HP7475 and relatives [number of pens] [eject]",
+ HPGL_XMAX, HPGL_YMAX, HPGL_VCHAR, HPGL_HCHAR,
+ HPGL_VTIC, HPGL_HTIC, HPGL_options, HPGL_init, HPGL_reset,
+ HPGL_text, null_scale, HPGL_graphics, HPGL_move, HPGL_vector,
+ HPGL_linetype, HPGL_put_text, HPGL_text_angle, null_justify_text, do_point, do_arrow, set_font_null TERM_TABLE_END(hpgl_driver)
+#undef LAST_TERM
+#define LAST_TERM hpgl_driver
+ TERM_TABLE_START(pcl5_driver)
+ "pcl5", "HP Designjet 750C, HP Laserjet III/IV, etc. (many options)",
+ PCL_XMAX, PCL_YMAX, HPGL2_VCHAR, HPGL2_HCHAR,
+ PCL_VTIC, PCL_HTIC, PCL_options, PCL_init, PCL_reset,
+ PCL_text, null_scale, PCL_graphics, HPGL2_move, HPGL2_vector,
+ HPGL2_linetype, HPGL2_put_text, HPGL2_text_angle,
+ HPGL2_justify_text, HPGL2_point, do_arrow, HPGL2_set_font, HPGL2_pointsize TERM_TABLE_END(pcl5_driver)
+#undef LAST_TERM
+#define LAST_TERM pcl5_driver
+#endif /* TERM_TABLE */
+#endif /* TERM_PROTO_ONLY */
+#ifdef TERM_HELP
+START_HELP(hpgl)
+"1 hpgl",
+"?commands set terminal hpgl",
+"?set terminal hpgl",
+"?set term hpgl",
+"?terminal hpgl",
+"?term hpgl",
+"?hpgl",
+"?commands set terminal pcl5",
+"?set terminal pcl5",
+"?set term pcl5",
+"?terminal pcl5",
+"?term pcl5",
+"?pcl5",
+" The `hpgl` driver produces HPGL output for devices like the HP7475A plotter.",
+" There are two options which can be set: the number of pens and `eject`,",
+" which tells the plotter to eject a page when done. The default is to use 6",
+" pens and not to eject the page when done.",
+"",
+" The international character sets ISO-8859-1 and CP850 are recognized via",
+" `set encoding iso_8859_1` or `set encoding cp850` (see `set encoding` for",
+" details).",
+"",
+" Syntax:",
+" set terminal hpgl {<number_of_pens>} {eject}",
+"",
+" The selection",
+"",
+" set terminal hpgl 8 eject",
+"",
+" is equivalent to the previous `hp7550` terminal, and the selection",
+"",
+" set terminal hpgl 4",
+"",
+" is equivalent to the previous `hp7580b` terminal.",
+"",
+" The `pcl5` driver supports plotters such as the Hewlett-Packard Designjet",
+" 750C, the Hewlett-Packard Laserjet III, and the Hewlett-Packard Laserjet IV.",
+" It actually uses HPGL-2, but there is a name conflict among the terminal",
+" devices. It has several options which must be specified in the order",
+" indicated below:",
+"",
+" Syntax:",
+" set terminal pcl5 {mode <mode>} {<plotsize>}",
+" {{color {<number_of_pens>}} | monochrome} {solid | dashed}",
+" {font <font>} {size <fontsize>} {pspoints | nopspoints}",
+"",
+" <mode> is `landscape` or `portrait`. <plotsize> is the physical",
+" plotting size of the plot, which is one of the following: `letter` for",
+" standard (8 1/2\" X 11\") displays, `legal` for (8 1/2\" X 14\") displays,",
+" `noextended` for (36\" X 48\") displays (a letter size ratio) or,",
+" `extended` for (36\" X 55\") displays (almost a legal size ratio).",
+" `color` is for multi-pen (i.e. color) plots, and <number_of_pens> is",
+" the number of pens (i.e. colors) used in color plots. `monochrome` is for",
+" one (e.g. black) pen plots. `solid` draws all lines as solid lines, or",
+" `dashed` will draw lines with different dashed and dotted line patterns.",
+" <font> is `stick`, `univers`, `cg_times`, `zapf_dingbats`, `antique_olive`,",
+" `arial`, `courier`, `garamond_antigua`, `letter_gothic`, `cg_omega`,",
+" `albertus`, `times_new_roman`, `clarendon`, `coronet`, `marigold`,",
+" `truetype_symbols`, or `wingdings`. <fontsize> is the font size in points.",
+" The point type selection can be the standard default set by specifying",
+" `nopspoints`, or the same set of point types found in the postscript terminal",
+" by specifying `pspoints`.",
+"",
+" Note that built-in support of some of these options is printer device",
+" dependent. For instance, all the fonts are supposedly supported by the HP",
+" Laserjet IV, but only a few (e.g. univers, stick) may be supported by the HP",
+" Laserjet III and the Designjet 750C. Also, color obviously won't work on the",
+" the laserjets since they are monochrome devices.",
+"",
+" Defaults: landscape, noextended, color (6 pens), solid, univers, 12 point,",
+" and nopspoints.",
+"",
+" With `pcl5` international characters are handled by the printer; you just put",
+" the appropriate 8-bit character codes into the text strings. You don't need",
+" to bother with `set encoding`.",
+"",
+" HPGL graphics can be imported by many software packages."
+END_HELP(hpgl)
+#endif /* TERM_HELP */
projects / gnuplot / blobdiff