Annotation of OpenXM_contrib/gnuplot/term/hp26.trm, Revision 1.1.1.1
1.1 maekawa 1: /*
2: * $Id: hp26.trm,v 1.14 1998/04/14 00:17:47 drd Exp $
3: */
4:
5: /* GNUPLOT - HP26.trm */
6:
7: /*[
8: * Copyright 1990 - 1993, 1998
9: *
10: * Permission to use, copy, and distribute this software and its
11: * documentation for any purpose with or without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and
13: * that both that copyright notice and this permission notice appear
14: * in supporting documentation.
15: *
16: * Permission to modify the software is granted, but not the right to
17: * distribute the complete modified source code. Modifications are to
18: * be distributed as patches to the released version. Permission to
19: * distribute binaries produced by compiling modified sources is granted,
20: * provided you
21: * 1. distribute the corresponding source modifications from the
22: * released version in the form of a patch file along with the binaries,
23: * 2. add special version identification to distinguish your version
24: * in addition to the base release version number,
25: * 3. provide your name and address as the primary contact for the
26: * support of your modified version, and
27: * 4. retain our contact information in regard to use of the base
28: * software.
29: * Permission to distribute the released version of the source code along
30: * with corresponding source modifications in the form of a patch file is
31: * granted with same provisions 2 through 4 for binary distributions.
32: *
33: * This software is provided "as is" without express or implied warranty
34: * to the extent permitted by applicable law.
35: ]*/
36:
37: /*
38: * This file is included by ../term.c.
39: *
40: * This terminal driver supports:
41: * HP2623A
42: *
43: * AUTHORS
44: * luecken@udel.edu (Bruce Lueckenhoff)
45: * hplvlch!ch (Chuck Heller)
46: *
47: * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
48: *
49: */
50:
51: /*
52: * adapted to the new terminal layout by Stefan Bodewig (Dec. 1995)
53: */
54:
55: #include "driver.h"
56:
57: #ifdef TERM_REGISTER
58: register_term(hp2623a)
59: #endif
60:
61: #ifdef TERM_PROTO
62: TERM_PUBLIC void HP26_vector __PROTO((unsigned int x, unsigned int y));
63: TERM_PUBLIC void HP26_move __PROTO((unsigned int x, unsigned int y));
64: TERM_PUBLIC void HP26_init __PROTO((void));
65: TERM_PUBLIC void HP26_graphics __PROTO((void));
66: TERM_PUBLIC void HP26_text __PROTO((void));
67: TERM_PUBLIC void HP26_reset __PROTO((void));
68: TERM_PUBLIC int HP26_text_angle __PROTO((int ang));
69: TERM_PUBLIC void HP26_put_text __PROTO((unsigned int x, unsigned int y, char *str));
70: TERM_PUBLIC void HP26_linetype __PROTO((int linetype));
71: TERM_PUBLIC void HP26_line_and_point __PROTO((unsigned int x, unsigned int y, int number));
72:
73: #define HP26_XMAX 512
74: #define HP26_YMAX 390
75:
76: /* Use a size 1 character, or a 7 x 10 grid. */
77: #define HP26_VCHAR 10
78: #define HP26_HCHAR 7
79: #define HP26_VTIC 5
80: #define HP26_HTIC 5
81: #endif /* TERM_PROTO */
82:
83: #ifndef TERM_PROTO_ONLY
84: #ifdef TERM_BODY
85: /* include the stream compaction routines */
86:
87: #define HP26_XLAST (HP26_XMAX - 1)
88: #define HP26_YLAST (HP26_XMAX - 1)
89:
90: void HP26_do_point __PROTO((unsigned int x, unsigned int y, int number));
91: int compact_slope __PROTO((int xp[], int yp[], int isa_move[], int *sz, double delta));
92: int compact_int __PROTO((int xp[], int yp[], int isa_move[], int *size));
93: struct _HP26_Buffer_Node *BN_create __PROTO((int index, int size, int linetype));
94: void BN_delete __PROTO((struct _HP26_Buffer_Node * the_node));
95: int HP26_flush __PROTO((struct _HP26_Buffer_Node * the_buff));
96: void HP26_handle_overflow __PROTO((void));
97:
98: #include "compact.c"
99:
100: typedef struct _HP26_Buffer_Node {
101: int index;
102: int size;
103: int next;
104: int linetype;
105: int *x;
106: int *y;
107: TBOOLEAN *isa_move;
108: } HP26_Buffer_Node;
109:
110: /* constructor method */
111: HP26_Buffer_Node *BN_create(index, size, linetype)
112: int index, size, linetype;
113: {
114: HP26_Buffer_Node *the_node;
115: the_node = (HP26_Buffer_Node *) malloc(sizeof(HP26_Buffer_Node));
116: the_node->index = index;
117: the_node->linetype = linetype;
118: the_node->size = size;
119: the_node->next = 0;
120: the_node->x = (int *) calloc(the_node->size, sizeof(int));
121: the_node->y = (int *) calloc(the_node->size, sizeof(int));
122: the_node->isa_move = (TBOOLEAN *) calloc(the_node->size, sizeof(TBOOLEAN));
123: if (the_node->x == NULL
124: || the_node->y == NULL
125: || the_node->isa_move == NULL)
126: return (NULL);
127: else
128: return (the_node);
129: }
130:
131: /* destructor method */
132: void BN_delete(the_node)
133: HP26_Buffer_Node *the_node;
134: {
135: free(the_node->x);
136: free(the_node->y);
137: free(the_node->isa_move);
138: free(the_node);
139: }
140:
141: /* 2 for border and axes + 9 for plots + 1 for dots */
142: #define HP26_gnu_map_size 12
143: HP26_Buffer_Node *HP26_gnu_map[HP26_gnu_map_size];
144: HP26_Buffer_Node *HP26_buff;
145: int HP26_pen_x;
146: int HP26_pen_y;
147: int HP26_angle;
148: int HP26_cursor_x;
149: int HP26_cursor_y;
150: TBOOLEAN HP26_in_text;
151: int HP26_linetype_current;
152: int HP26_reduction_int;
153: int HP26_reduction_slope;
154: int HP26_overflows;
155: int HP26_nop_move;
156: int HP26_nop_vect;
157: int HP26_nop_line;
158:
159: /* linetype stuff */
160: #define SOLID 1
161: #define USER 2
162: #define LINE3 3
163: #define LINE4 4
164: #define LINE5 5
165: #define LINE6 6
166: #define DOTS 7
167: #define LINE8 8
168: #define LINE9 9
169: #define LINE10 10
170: #define POINT 11
171:
172:
173:
174: #define swap(a, b) a ^= b; b ^= a; a ^= b;
175:
176: char HP26_bin_short_table[32] =
177: {
178: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>',
179: '?', ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-',
180: '.', '/'
181: };
182: /* encodes an integer (assumed to be in range) into
183: binary short incremental format (j)*/
184: #define short_encode(n) (HP26_bin_short_table[n+16])
185:
186: /* tells whether a given delta_x,delta_y pair can be expressed in
187: binary short incremental format */
188: #define qualified(dx,dy) ((dx>-17)&&(dy>-17)&&(dx<16)&&(dy<16))
189:
190:
191: char HP26_bin_table[32] =
192: {
193: ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-',
194: '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<',
195: '=', '>', '?'
196: };
197: /* returns the high byte of integer n in binary absolute format (i) */
198: #define bin_encode_hi(n) (HP26_bin_table[n>>5])
199: /* returns the low byte of integer n in binary absolute format (i) */
200: #define bin_encode_lo(n) (HP26_bin_table[n & 31])
201:
202:
203:
204: /* the guts of the program
205: -- first checks if any work need be done and, failing that, returns
206: immediately
207: -- tries to compress the vector stream
208: -- goes through the buffer, using binary short incremental (2 bytes/point)
209: as much as possible, even if must output two pairs to express one vector
210: (it's no more expensive, and will hopefully damp any excessive switching
211: back and forth between the two formats)
212: if can't use binary short incremental, use binary
213: absolute(4 bytes/point)
214: -- finally, resets the HP26_next pointer to zero */
215: int HP26_flush(the_buff)
216: HP26_Buffer_Node *the_buff;
217: {
218: int i, delta_x, delta_y, half_dx, half_dy;
219: int *buff_x, *buff_y;
220: TBOOLEAN *isa_move;
221: TBOOLEAN bin_short;
222:
223: if (the_buff->next == 0)
224: return (FALSE);
225: /* init pointers for easy access */
226: buff_x = the_buff->x;
227: buff_y = the_buff->y;
228: isa_move = the_buff->isa_move;
229: if (HP26_in_text) {
230: fputs("\033*dT", gpoutfile);
231: HP26_in_text = FALSE;
232: }
233: if (HP26_linetype_current != the_buff->linetype
234: && (the_buff->next > 1 || !isa_move[0])) {
235: fprintf(gpoutfile, "\033*m%dB", the_buff->linetype);
236: HP26_linetype_current = the_buff->linetype;
237: }
238: /* try to compress the stream */
239: if (the_buff->next > 30 && the_buff->linetype != POINT) {
240: /* HP26_reduction_int += compact_int(buff_x,buff_y,isa_move, &(the_buff->next)); */
241: HP26_reduction_slope += compact_slope(buff_x, buff_y, isa_move, &(the_buff->next), 0.1);
242: }
243: /* start escape sequence */
244: fputs("\033*p", gpoutfile);
245: /* initialize the state: binary short incremental or binary absolute */
246: delta_x = buff_x[0] - HP26_pen_x;
247: delta_y = buff_y[0] - HP26_pen_y;
248: if (qualified(delta_x, delta_y)) {
249: fputc('j', gpoutfile);
250: bin_short = TRUE;
251: } else {
252: fputc('i', gpoutfile);
253: bin_short = FALSE;
254: }
255: /* now work through the list */
256: for (i = 0; i < the_buff->next; i++) {
257: if (i > 0) {
258: delta_x = buff_x[i] - buff_x[i - 1];
259: delta_y = buff_y[i] - buff_y[i - 1];
260: }
261: if ((delta_x == 0) && (delta_y == 0)) {
262: if (i > 0 && !isa_move[i - 1] && !isa_move[i]) {
263: /* allow null vectors only when drawing dots */
264: HP26_nop_vect++;
265: continue;
266: } else if (isa_move[i]) {
267: /* a null move */
268: HP26_nop_move++;
269: continue;
270: }
271: } else if (i > 0
272: && i + 1 < the_buff->next
273: && isa_move[i]
274: && isa_move[i + 1]) {
275: /* consecutive moves are condensed into one */
276: HP26_nop_move++;
277: continue;
278: } else if (!qualified(delta_x, delta_y)
279: && i > 0
280: && i + 2 < the_buff->next
281: && isa_move[i]
282: && !isa_move[i + 1]
283: && isa_move[i + 2]
284: && qualified(buff_x[i + 1] - buff_x[i - 1], buff_y[i + 1] - buff_y[i - 1])) {
285: swap(buff_x[i], buff_x[i + 1]);
286: swap(buff_y[i], buff_y[i + 1]);
287: /* set up new delta_x & delta_y */
288: delta_x = buff_x[i] - buff_x[i - 1];
289: delta_y = buff_y[i] - buff_y[i - 1];
290: }
291: if (qualified(delta_x, delta_y)) {
292: if (!bin_short) {
293: fputc('j', gpoutfile);
294: bin_short = TRUE;
295: }
296: if (isa_move[i])
297: fputc('a', gpoutfile);
298: fputc(short_encode(delta_x), gpoutfile);
299: fputc(short_encode(delta_y), gpoutfile);
300: } else {
301: half_dx = (delta_x + (delta_x > 0 ? 1 : -1)) / 2;
302: half_dy = (delta_y + (delta_y > 0 ? 1 : -1)) / 2;
303: if (bin_short && qualified(half_dx, half_dy)) {
304: if (isa_move[i])
305: fputc('a', gpoutfile);
306: fputc(short_encode(half_dx), gpoutfile);
307: fputc(short_encode(half_dy), gpoutfile);
308: if (isa_move[i])
309: fputc('a', gpoutfile);
310: fputc(short_encode(delta_x - half_dx), gpoutfile);
311: fputc(short_encode(delta_y - half_dy), gpoutfile);
312: } else {
313: if (bin_short) {
314: bin_short = FALSE;
315: fputc('i', gpoutfile);
316: }
317: if (isa_move[i])
318: fputc('a', gpoutfile);
319: fputc(bin_encode_hi(buff_x[i]), gpoutfile);
320: fputc(bin_encode_lo(buff_x[i]), gpoutfile);
321: fputc(bin_encode_hi(buff_y[i]), gpoutfile);
322: fputc(bin_encode_lo(buff_y[i]), gpoutfile);
323: }
324: }
325: } /* end for.. */
326: /* the term doesn't seem to mind leaving this out */
327: /* finish the escape sequence */
328: fputc('Z', gpoutfile);
329: /* set these for next time */
330: HP26_pen_x = buff_x[the_buff->next - 1];
331: HP26_pen_y = buff_y[the_buff->next - 1];
332: the_buff->next = 0;
333: return (TRUE);
334: }
335:
336: void HP26_handle_overflow()
337: {
338: HP26_Buffer_Node *bigger, *old;
339: int x, y;
340: x = (HP26_buff->x)[HP26_buff->next - 1];
341: y = (HP26_buff->y)[HP26_buff->next - 1];
342: HP26_flush(HP26_buff);
343: bigger = BN_create(HP26_buff->index, HP26_buff->size * 2,
344: HP26_buff->linetype);
345: if (bigger != NULL) {
346: old = HP26_buff;
347: HP26_gnu_map[bigger->index] = bigger;
348: /* special case since DOTS entry is shared 3 ways */
349: if (bigger->index == 0) {
350: HP26_gnu_map[1] = bigger;
351: HP26_gnu_map[3] = bigger;
352: }
353: HP26_buff = bigger;
354: BN_delete(old);
355: }
356: (HP26_buff->x)[0] = x;
357: (HP26_buff->y)[0] = y;
358: (HP26_buff->isa_move)[0] = TRUE;
359: HP26_buff->next = 1;
360: HP26_overflows++;
361: }
362:
363: /* checks for NOP, overcapacity condition, and then adds vector to the list */
364: TERM_PUBLIC void HP26_vector(x, y)
365: unsigned int x, y;
366: {
367: if (HP26_buff->next > 2
368: && x == (HP26_buff->x)[HP26_buff->next - 1]
369: && y == (HP26_buff->y)[HP26_buff->next - 1]
370: && !(HP26_buff->isa_move)[HP26_buff->next - 1]) {
371: HP26_nop_vect++;
372: return;
373: }
374: if (HP26_buff->next == HP26_buff->size)
375: HP26_handle_overflow();
376: /* otherwise add to the list */
377: (HP26_buff->x)[HP26_buff->next] = x;
378: (HP26_buff->y)[HP26_buff->next] = y;
379: (HP26_buff->isa_move)[HP26_buff->next] = FALSE;
380: HP26_buff->next++;
381: }
382:
383: /* checks for NOP, checks for overcapacity, puts self on list */
384: TERM_PUBLIC void HP26_move(x, y)
385: unsigned int x, y;
386: {
387: if (HP26_buff->next > 0) {
388: if (((HP26_buff->x)[HP26_buff->next - 1] == x)
389: && ((HP26_buff->y)[HP26_buff->next - 1] == y)) {
390: /* null moves are NOP's */
391: HP26_nop_move++;
392: return;
393: } else if ((HP26_buff->isa_move)[HP26_buff->next - 1]) {
394: /* consecutive moves are NOP's */
395: (HP26_buff->x)[HP26_buff->next - 1] = x;
396: (HP26_buff->y)[HP26_buff->next - 1] = y;
397: HP26_nop_move++;
398: return;
399: }
400: }
401: if (HP26_buff->next == HP26_buff->size)
402: HP26_handle_overflow();
403: (HP26_buff->x)[HP26_buff->next] = x;
404: (HP26_buff->y)[HP26_buff->next] = y;
405: (HP26_buff->isa_move)[HP26_buff->next] = TRUE;
406: HP26_buff->next++;
407: return;
408: }
409:
410: TERM_PUBLIC void HP26_init()
411: {
412: HP26_gnu_map[-2 + 2] = BN_create(0, 2048, DOTS); /* border */
413: HP26_gnu_map[-1 + 2] = HP26_gnu_map[-2 + 2]; /* axes */
414: HP26_gnu_map[0 + 2] = BN_create(2, 3072, SOLID); /* plot 0 */
415: HP26_gnu_map[1 + 2] = HP26_gnu_map[-2 + 2]; /* plot 1 */
416: HP26_gnu_map[2 + 2] = BN_create(4, 1024, LINE5); /* plot 2 */
417: HP26_gnu_map[3 + 2] = BN_create(5, 256, LINE6); /* plot 3 */
418: HP26_gnu_map[4 + 2] = BN_create(6, 256, LINE8); /* plot 4 */
419: HP26_gnu_map[5 + 2] = BN_create(7, 128, LINE9); /* plot 5 */
420: HP26_gnu_map[6 + 2] = BN_create(8, 128, LINE10); /* plot 6 */
421: HP26_gnu_map[7 + 2] = BN_create(9, 64, LINE6); /* plot 7 */
422: HP26_gnu_map[8 + 2] = BN_create(10, 64, LINE4); /* plot 8 */
423: HP26_gnu_map[9 + 2] = BN_create(11, 512, POINT); /* point plot */
424: HP26_buff = HP26_gnu_map[10]; /* set to an unlikely linetype */
425: HP26_linetype_current = 0; /* set to force a linetype change */
426: HP26_angle = 1; /* left to right, default */
427: fputs("\033*mp1m2a2Q", gpoutfile);
428: /* 1 2 3 4
429: 1. make text upright
430: 2. select text size 1
431: 3. make SET the default drawing op
432: 4. left justify text */
433: fflush(gpoutfile);
434: }
435:
436:
437: TERM_PUBLIC void HP26_graphics()
438: {
439: fputs("\033*daflsC", gpoutfile);
440: /* 12345
441: 1. clear graphics display
442: 2. shut off the alphanumeric display
443: 3. graphics cursor off
444: 4. into graphics text mode
445: 5. enable graphics display */
446: /* set the pen & cursor positions to force an initial absolute move */
447: HP26_pen_x = HP26_pen_y = -200;
448: HP26_cursor_x = HP26_cursor_y = 800;
449: HP26_in_text = TRUE;
450: /* initialize statistics */
451: HP26_reduction_int = 0;
452: HP26_reduction_slope = 0;
453: HP26_nop_move = 0;
454: HP26_nop_vect = 0;
455: HP26_nop_line = 0;
456: HP26_overflows = 0;
457: }
458:
459:
460: TERM_PUBLIC void HP26_text()
461: {
462: int i, j, curr;
463:
464: /* always flush the current line first */
465: for (i = 0; i < HP26_gnu_map_size; i++)
466: if ((HP26_gnu_map[i])->linetype == HP26_linetype_current)
467: HP26_flush(HP26_gnu_map[i]);
468: /* now flush the rest of the lines */
469: for (i = 0; i < HP26_gnu_map_size; i++) {
470: HP26_flush(HP26_gnu_map[i]);
471: curr = HP26_gnu_map[i]->linetype;
472: for (j = 0; j < HP26_gnu_map_size; j++)
473: if ((HP26_gnu_map[j])->linetype == curr)
474: HP26_flush(HP26_gnu_map[j]);
475: }
476: fputs("\033*deT", gpoutfile);
477: /* 12
478: 1. turn on the alphanumeric display
479: 2. back to text mode */
480: fflush(gpoutfile);
481: /* informational: tells how many points compressed, how
482: many NOP's of each type, and how many times a buffer
483: overflowed during this plot */
484: /*
485: if(HP26_reduction_int
486: + HP26_reduction_slope
487: + HP26_nop_move
488: + HP26_nop_vect
489: + HP26_overflows
490: + HP26_nop_line > 0){
491: if (HP26_reduction_int>0)
492: printf("%d int-compress",HP26_reduction_int);
493: if (HP26_reduction_slope>0)
494: printf("%d slope-compress",HP26_reduction_slope);
495: if (HP26_nop_move>0)
496: printf(" %d nop_move",HP26_nop_move);
497: if (HP26_nop_vect>0)
498: printf(" %d nop_vect",HP26_nop_vect);
499: if (HP26_nop_line>0)
500: printf(" %d nop_line",HP26_nop_line);
501: if (HP26_overflows>0)
502: printf(" %d buffer overflows",HP26_overflows);
503: printf("\n");
504: }
505: */
506: }
507:
508: TERM_PUBLIC void HP26_reset()
509: {
510: int i;
511: for (i = 2; i < HP26_gnu_map_size; i++)
512: BN_delete(HP26_gnu_map[i]);
513: }
514:
515: TERM_PUBLIC int HP26_text_angle(ang)
516: int ang;
517: {
518: HP26_angle = ang + 1;
519: fprintf(gpoutfile, "\033*m%dN", HP26_angle);
520: return (TRUE);
521: }
522:
523:
524: TERM_PUBLIC void HP26_put_text(x, y, str)
525: unsigned int x, y;
526: char *str;
527: {
528: char abs_str[10], rel_str[10];
529:
530: if (!strlen(str))
531: return;
532: else {
533: fputs("\033*d", gpoutfile);
534: if (!HP26_in_text) {
535: fputc('s', gpoutfile);
536: HP26_in_text = TRUE;
537: }
538: sprintf(rel_str, "%d,%dP", x - HP26_cursor_x, y - HP26_cursor_y);
539: sprintf(abs_str, "%d,%dO", x, y);
540: if (strlen(rel_str) < strlen(abs_str))
541: fputs(rel_str, gpoutfile);
542: else
543: fputs(abs_str, gpoutfile);
544: fputs(str, gpoutfile);
545: HP26_pen_x = HP26_cursor_x = x;
546: HP26_pen_y = HP26_cursor_y = y;
547: }
548: /*
549: tmp = &(HP26_all_buffers[HP26_linetype_current]);
550: tmp->x[tmp->next] = x;
551: tmp->y[tmp->next] = y;
552: tmp->isa_move[tmp->next] = TRUE;
553: tmp->next++;
554: HP26_flush(tmp);
555: fprintf(gpoutfile,"\033*l%s\r",str);
556: */
557: return;
558: }
559:
560:
561: /* checks for NOP, sets HP26_buff to point to the right buffer */
562: TERM_PUBLIC void HP26_linetype(linetype)
563: int linetype;
564: {
565: if (linetype > 8)
566: linetype %= 9;
567: linetype += 2;
568: if (HP26_gnu_map[linetype] == HP26_buff) {
569: HP26_nop_line++;
570: return; /* gnuplot just sent us another NOP */
571: }
572: HP26_buff = HP26_gnu_map[linetype];
573: }
574:
575:
576:
577: /* switches to a solid linetype and calls do_point, then switches back */
578: TERM_PUBLIC void HP26_line_and_point(x, y, number)
579: unsigned int x, y;
580: int number;
581: {
582: int line_save, not_solid;
583:
584: /* shut up warnings with dummy initializer -SB */
585: line_save = 0;
586: not_solid = (HP26_buff->linetype != SOLID);
587: if (not_solid) {
588: line_save = HP26_buff->linetype;
589: HP26_linetype(0); /*switch to a solid line */
590: }
591: HP26_do_point(x, y, number);
592: if (not_solid)
593: HP26_linetype(line_save);
594: }
595:
596:
597: /* provides 9 point types so they stay in sync with the linetypes
598: puts simpler point types first on the assumption they are more
599: frequently used */
600: void HP26_do_point(x, y, number)
601: unsigned int x, y;
602: int number;
603: {
604: int htic, vtic;
605: HP26_Buffer_Node *tmp;
606:
607: vtic = HP26_VTIC / 2;
608: htic = HP26_HTIC / 2;
609: if (number < 0) {
610: /* do a dot -- special case */
611: tmp = HP26_buff;
612: HP26_buff = HP26_gnu_map[11]; /* point plot */
613: HP26_vector(x, y);
614: HP26_buff = tmp;
615: }
616: switch (number % 9) {
617: case 0:
618: /* do triangle */
619: HP26_move(x - htic, y - vtic);
620: HP26_vector(x, y + vtic);
621: HP26_vector(x + htic, y - vtic);
622: HP26_vector(x - htic, y - vtic);
623: break;
624: case 1:
625: /* do nambla */
626: HP26_move(x - htic, y + vtic);
627: HP26_vector(x, y - vtic);
628: HP26_vector(x + htic, y + vtic);
629: HP26_vector(x - htic, y + vtic);
630: break;
631: case 2:
632: /* do left triangle */
633: HP26_move(x - htic, y);
634: HP26_vector(x + htic, y + vtic);
635: HP26_vector(x + htic, y - vtic);
636: HP26_vector(x - htic, y);
637: break;
638: case 3:
639: /* do right triangle */
640: HP26_move(x + htic, y);
641: HP26_vector(x - htic, y + vtic);
642: HP26_vector(x - htic, y - vtic);
643: HP26_vector(x + htic, y);
644: break;
645: case 4:
646: /* do box */
647: HP26_move(x - htic, y - vtic);
648: HP26_vector(x - htic, y + vtic);
649: HP26_vector(x + htic, y + vtic);
650: HP26_vector(x + htic, y - vtic);
651: HP26_vector(x - htic, y - vtic);
652: break;
653: case 5:
654: /* do plus */
655: HP26_move(x, y + vtic);
656: HP26_vector(x, y - vtic);
657: HP26_move(x - htic, y);
658: HP26_vector(x + htic, y);
659: break;
660: case 6:
661: /* do X */
662: HP26_move(x + htic, y + vtic);
663: HP26_vector(x - htic, y - vtic);
664: HP26_move(x - htic, y + vtic);
665: HP26_vector(x + htic, y - vtic);
666: break;
667: default:
668: /* do diamond */
669: HP26_move(x, y - vtic);
670: HP26_vector(x - htic, y);
671: HP26_vector(x, y + vtic);
672: HP26_vector(x + htic, y);
673: HP26_vector(x, y - vtic);
674: break;
675: }
676: }
677:
678: #endif /* TERM_BODY */
679:
680: #ifdef TERM_TABLE
681:
682: TERM_TABLE_START(hp2623a_driver)
683: "hp2623A", "HP2623A and maybe others",
684: HP26_XMAX, HP26_YMAX, HP26_VCHAR, HP26_HCHAR,
685: HP26_VTIC, HP26_HTIC, options_null, HP26_init, HP26_reset,
686: HP26_text, null_scale, HP26_graphics, HP26_move, HP26_vector,
687: HP26_linetype, HP26_put_text, HP26_text_angle,
688: null_justify_text, HP26_line_and_point, do_arrow, set_font_null
689: TERM_TABLE_END(hp2623a_driver)
690:
691: #undef LAST_TERM
692: #define LAST_TERM hp2623a_driver
693:
694: #endif /* TERM_TABLE */
695: #endif /* TERM_PROTO_ONLY */
696:
697: #ifdef TERM_HELP
698: START_HELP(hp2623a)
699: "1 hp2623a",
700: "?commands set terminal hp2623a",
701: "?set terminal hp2623a",
702: "?set term hp2623a",
703: "?terminal hp2623a",
704: "?term hp2623a",
705: "?hp2623a",
706: " The `hp2623a` terminal driver supports the Hewlett Packard HP2623A. It has",
707: " no options."
708: END_HELP(hp2623a)
709: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hp26.trm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / term