PLplot  5.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
tclgen.c
Go to the documentation of this file.
1 /*--------------------------------------------------------------------------*\
2  * pl_setcontlabelformatCmd
3  *
4  * Processes pl_setcontlabelformat Tcl command.
5 \*--------------------------------------------------------------------------*/
6 
7 static int
8 pl_setcontlabelformatCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
9 {
10  PLINT lexp;
11  PLINT sigprec;
12 
13  pl_errcode = 0; errmsg[0] = '\0';
14 
15  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
16  Tcl_AppendResult( interp, "command syntax: \"",
17  "pl_setcontlabelformat lexp sigprec", "\"",
18  (char *) NULL);
19  return TCL_ERROR;
20  }
21 
22  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
23  (!0 && !0 && (argc != (2 + 1))) ||
24  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
25  Tcl_AppendResult( interp, "wrong # args: should be \"",
26  "pl_setcontlabelformat lexp sigprec", "\"",
27  (char *) NULL);
28  return TCL_ERROR;
29  }
30 
31  lexp = atoi(argv[1+0]);
32  sigprec = atoi(argv[1+1]);
33 
34  pl_setcontlabelformat ( lexp, sigprec );
35 
36 
37  if (pl_errcode != 0) {
38  Tcl_AppendResult(interp, errmsg, (char *) NULL);
39  return TCL_ERROR;
40  }
41 
42  plflush();
43  return TCL_OK;
44 }
45 
46 /*--------------------------------------------------------------------------*\
47  * pl_setcontlabelparamCmd
48  *
49  * Processes pl_setcontlabelparam Tcl command.
50 \*--------------------------------------------------------------------------*/
51 
52 static int
53 pl_setcontlabelparamCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
54 {
55  PLFLT offset;
56  PLFLT size;
57  PLFLT spacing;
58  PLINT active;
59 
60  pl_errcode = 0; errmsg[0] = '\0';
61 
62  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
63  Tcl_AppendResult( interp, "command syntax: \"",
64  "pl_setcontlabelparam offset size spacing active", "\"",
65  (char *) NULL);
66  return TCL_ERROR;
67  }
68 
69  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
70  (!0 && !0 && (argc != (4 + 1))) ||
71  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
72  Tcl_AppendResult( interp, "wrong # args: should be \"",
73  "pl_setcontlabelparam offset size spacing active", "\"",
74  (char *) NULL);
75  return TCL_ERROR;
76  }
77 
78  offset = atof(argv[1+0]);
79  size = atof(argv[1+1]);
80  spacing = atof(argv[1+2]);
81  active = atoi(argv[1+3]);
82 
83  pl_setcontlabelparam ( offset, size, spacing, active );
84 
85 
86  if (pl_errcode != 0) {
87  Tcl_AppendResult(interp, errmsg, (char *) NULL);
88  return TCL_ERROR;
89  }
90 
91  plflush();
92  return TCL_OK;
93 }
94 
95 /*--------------------------------------------------------------------------*\
96  * pladvCmd
97  *
98  * Processes pladv Tcl command.
99 \*--------------------------------------------------------------------------*/
100 
101 static int
102 pladvCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
103 {
104  PLINT page = 0;
105 
106  pl_errcode = 0; errmsg[0] = '\0';
107 
108  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
109  Tcl_AppendResult( interp, "command syntax: \"",
110  "pladv page", "\"",
111  (char *) NULL);
112  return TCL_ERROR;
113  }
114 
115  if ( (!0 && 1 && (argc < (1 + 1 - 1))) ||
116  (!0 && !1 && (argc != (1 + 1))) ||
117  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
118  Tcl_AppendResult( interp, "wrong # args: should be \"",
119  "pladv page", "\"",
120  (char *) NULL);
121  return TCL_ERROR;
122  }
123 
124  if (argc > 0+1) {
125  page = atoi(argv[1+0]);
126  }
127 
128  pladv ( page );
129 
130 
131  if (pl_errcode != 0) {
132  Tcl_AppendResult(interp, errmsg, (char *) NULL);
133  return TCL_ERROR;
134  }
135 
136  plflush();
137  return TCL_OK;
138 }
139 
140 /*--------------------------------------------------------------------------*\
141  * plarcCmd
142  *
143  * Processes plarc Tcl command.
144 \*--------------------------------------------------------------------------*/
145 
146 static int
147 plarcCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
148 {
149  PLFLT x;
150  PLFLT y;
151  PLFLT a;
152  PLFLT b;
153  PLFLT angle1;
154  PLFLT angle2;
155  PLFLT rotate;
156  PLINT fill;
157 
158  pl_errcode = 0; errmsg[0] = '\0';
159 
160  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
161  Tcl_AppendResult( interp, "command syntax: \"",
162  "plarc x y a b angle1 angle2 rotate fill", "\"",
163  (char *) NULL);
164  return TCL_ERROR;
165  }
166 
167  if ( (!0 && 0 && (argc < (1 + 8 - 0))) ||
168  (!0 && !0 && (argc != (8 + 1))) ||
169  ( 0 && (argc != 1) && (argc != (8 + 1))) ) {
170  Tcl_AppendResult( interp, "wrong # args: should be \"",
171  "plarc x y a b angle1 angle2 rotate fill", "\"",
172  (char *) NULL);
173  return TCL_ERROR;
174  }
175 
176  x = atof(argv[1+0]);
177  y = atof(argv[1+1]);
178  a = atof(argv[1+2]);
179  b = atof(argv[1+3]);
180  angle1 = atof(argv[1+4]);
181  angle2 = atof(argv[1+5]);
182  rotate = atof(argv[1+6]);
183  fill = atoi(argv[1+7]);
184 
185  plarc ( x, y, a, b, angle1, angle2, rotate, fill );
186 
187 
188  if (pl_errcode != 0) {
189  Tcl_AppendResult(interp, errmsg, (char *) NULL);
190  return TCL_ERROR;
191  }
192 
193  plflush();
194  return TCL_OK;
195 }
196 
197 /*--------------------------------------------------------------------------*\
198  * plaxesCmd
199  *
200  * Processes plaxes Tcl command.
201 \*--------------------------------------------------------------------------*/
202 
203 static int
204 plaxesCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
205 {
206  PLFLT x0;
207  PLFLT y0;
208  const char *xopt;
209  PLFLT xtick;
210  PLINT nxsub;
211  const char *yopt;
212  PLFLT ytick;
213  PLINT nysub;
214 
215  pl_errcode = 0; errmsg[0] = '\0';
216 
217  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
218  Tcl_AppendResult( interp, "command syntax: \"",
219  "plaxes x0 y0 xopt xtick nxsub yopt ytick nysub", "\"",
220  (char *) NULL);
221  return TCL_ERROR;
222  }
223 
224  if ( (!0 && 0 && (argc < (1 + 8 - 0))) ||
225  (!0 && !0 && (argc != (8 + 1))) ||
226  ( 0 && (argc != 1) && (argc != (8 + 1))) ) {
227  Tcl_AppendResult( interp, "wrong # args: should be \"",
228  "plaxes x0 y0 xopt xtick nxsub yopt ytick nysub", "\"",
229  (char *) NULL);
230  return TCL_ERROR;
231  }
232 
233  x0 = atof(argv[1+0]);
234  y0 = atof(argv[1+1]);
235  xopt = argv[1+2];
236  xtick = atof(argv[1+3]);
237  nxsub = atoi(argv[1+4]);
238  yopt = argv[1+5];
239  ytick = atof(argv[1+6]);
240  nysub = atoi(argv[1+7]);
241 
242  plaxes ( x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub );
243 
244 
245  if (pl_errcode != 0) {
246  Tcl_AppendResult(interp, errmsg, (char *) NULL);
247  return TCL_ERROR;
248  }
249 
250  plflush();
251  return TCL_OK;
252 }
253 
254 /*--------------------------------------------------------------------------*\
255  * plbinCmd
256  *
257  * Processes plbin Tcl command.
258 \*--------------------------------------------------------------------------*/
259 
260 static int
261 plbinCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
262 {
263  PLINT nbin;
264  PLFLT *x;
265  tclMatrix *matx;
266  PLFLT *y;
267  tclMatrix *maty;
268  PLINT center;
269 
270  pl_errcode = 0; errmsg[0] = '\0';
271 
272  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
273  Tcl_AppendResult( interp, "command syntax: \"",
274  "plbin nbin x y center", "\"",
275  (char *) NULL);
276  return TCL_ERROR;
277  }
278 
279  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
280  (!0 && !0 && (argc != (4 + 1))) ||
281  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
282  Tcl_AppendResult( interp, "wrong # args: should be \"",
283  "plbin nbin x y center", "\"",
284  (char *) NULL);
285  return TCL_ERROR;
286  }
287 
288  nbin = atoi(argv[1+0]);
289  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
290  if (matx == NULL) return TCL_ERROR;
291  x = matx->fdata;
292  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
293  if (maty == NULL) return TCL_ERROR;
294  y = maty->fdata;
295  center = atoi(argv[1+3]);
296 
297  plbin ( nbin, x, y, center );
298 
299 
300  if (pl_errcode != 0) {
301  Tcl_AppendResult(interp, errmsg, (char *) NULL);
302  return TCL_ERROR;
303  }
304 
305  plflush();
306  return TCL_OK;
307 }
308 
309 /*--------------------------------------------------------------------------*\
310  * plbopCmd
311  *
312  * Processes plbop Tcl command.
313 \*--------------------------------------------------------------------------*/
314 
315 static int
316 plbopCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
317 {
318 
319  pl_errcode = 0; errmsg[0] = '\0';
320 
321  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
322  Tcl_AppendResult( interp, "command syntax: \"",
323  "plbop ", "\"",
324  (char *) NULL);
325  return TCL_ERROR;
326  }
327 
328  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
329  (!0 && !0 && (argc != (0 + 1))) ||
330  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
331  Tcl_AppendResult( interp, "wrong # args: should be \"",
332  "plbop ", "\"",
333  (char *) NULL);
334  return TCL_ERROR;
335  }
336 
337 
338  plbop ( );
339 
340 
341  if (pl_errcode != 0) {
342  Tcl_AppendResult(interp, errmsg, (char *) NULL);
343  return TCL_ERROR;
344  }
345 
346  plflush();
347  return TCL_OK;
348 }
349 
350 /*--------------------------------------------------------------------------*\
351  * plboxCmd
352  *
353  * Processes plbox Tcl command.
354 \*--------------------------------------------------------------------------*/
355 
356 static int
357 plboxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
358 {
359  const char *xopt;
360  PLFLT xtick;
361  PLINT nxsub;
362  const char *yopt;
363  PLFLT ytick;
364  PLINT nysub;
365 
366  pl_errcode = 0; errmsg[0] = '\0';
367 
368  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
369  Tcl_AppendResult( interp, "command syntax: \"",
370  "plbox xopt xtick nxsub yopt ytick nysub", "\"",
371  (char *) NULL);
372  return TCL_ERROR;
373  }
374 
375  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
376  (!0 && !0 && (argc != (6 + 1))) ||
377  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
378  Tcl_AppendResult( interp, "wrong # args: should be \"",
379  "plbox xopt xtick nxsub yopt ytick nysub", "\"",
380  (char *) NULL);
381  return TCL_ERROR;
382  }
383 
384  xopt = argv[1+0];
385  xtick = atof(argv[1+1]);
386  nxsub = atoi(argv[1+2]);
387  yopt = argv[1+3];
388  ytick = atof(argv[1+4]);
389  nysub = atoi(argv[1+5]);
390 
391  plbox ( xopt, xtick, nxsub, yopt, ytick, nysub );
392 
393 
394  if (pl_errcode != 0) {
395  Tcl_AppendResult(interp, errmsg, (char *) NULL);
396  return TCL_ERROR;
397  }
398 
399  plflush();
400  return TCL_OK;
401 }
402 
403 /*--------------------------------------------------------------------------*\
404  * plbox3Cmd
405  *
406  * Processes plbox3 Tcl command.
407 \*--------------------------------------------------------------------------*/
408 
409 static int
410 plbox3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
411 {
412  const char *xopt;
413  const char *xlabel;
414  PLFLT xtick;
415  PLINT nsubx;
416  const char *yopt;
417  const char *ylabel;
418  PLFLT ytick;
419  PLINT nsuby;
420  const char *zopt;
421  const char *zlabel;
422  PLFLT ztick;
423  PLINT nsubz;
424 
425  pl_errcode = 0; errmsg[0] = '\0';
426 
427  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
428  Tcl_AppendResult( interp, "command syntax: \"",
429  "plbox3 xopt xlabel xtick nsubx yopt ylabel ytick nsuby zopt zlabel ztick nsubz", "\"",
430  (char *) NULL);
431  return TCL_ERROR;
432  }
433 
434  if ( (!0 && 0 && (argc < (1 + 12 - 0))) ||
435  (!0 && !0 && (argc != (12 + 1))) ||
436  ( 0 && (argc != 1) && (argc != (12 + 1))) ) {
437  Tcl_AppendResult( interp, "wrong # args: should be \"",
438  "plbox3 xopt xlabel xtick nsubx yopt ylabel ytick nsuby zopt zlabel ztick nsubz", "\"",
439  (char *) NULL);
440  return TCL_ERROR;
441  }
442 
443  xopt = argv[1+0];
444  xlabel = argv[1+1];
445  xtick = atof(argv[1+2]);
446  nsubx = atoi(argv[1+3]);
447  yopt = argv[1+4];
448  ylabel = argv[1+5];
449  ytick = atof(argv[1+6]);
450  nsuby = atoi(argv[1+7]);
451  zopt = argv[1+8];
452  zlabel = argv[1+9];
453  ztick = atof(argv[1+10]);
454  nsubz = atoi(argv[1+11]);
455 
456  plbox3 ( xopt, xlabel, xtick, nsubx, yopt, ylabel, ytick, nsuby, zopt, zlabel, ztick, nsubz );
457 
458 
459  if (pl_errcode != 0) {
460  Tcl_AppendResult(interp, errmsg, (char *) NULL);
461  return TCL_ERROR;
462  }
463 
464  plflush();
465  return TCL_OK;
466 }
467 
468 /*--------------------------------------------------------------------------*\
469  * plbtimeCmd
470  *
471  * Processes plbtime Tcl command.
472 \*--------------------------------------------------------------------------*/
473 
474 static int
475 plbtimeCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
476 {
477  PLINT year;
478  PLINT month;
479  PLINT day;
480  PLINT hour;
481  PLINT min;
482  PLFLT sec;
483  PLFLT ctime;
484 
485  pl_errcode = 0; errmsg[0] = '\0';
486 
487  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
488  Tcl_AppendResult( interp, "command syntax: \"",
489  "plbtime ?year month day hour min sec ctime?", "\"",
490  (char *) NULL);
491  return TCL_ERROR;
492  }
493 
494  if ( (!1 && 0 && (argc < (1 + 7 - 0))) ||
495  (!1 && !0 && (argc != (7 + 1))) ||
496  ( 1 && (argc != 1) && (argc != (7 + 1))) ) {
497  Tcl_AppendResult( interp, "wrong # args: should be \"",
498  "plbtime ?year month day hour min sec ctime?", "\"",
499  (char *) NULL);
500  return TCL_ERROR;
501  }
502 
503 /* year is for output. */
504 /* month is for output. */
505 /* day is for output. */
506 /* hour is for output. */
507 /* min is for output. */
508 /* sec is for output. */
509  ctime = atof(argv[1+6]);
510 
511  plbtime ( &year, &month, &day, &hour, &min, &sec, ctime );
512 
513  sprintf( buf, "%d", year );
514  if (argc > 1)
515  Tcl_SetVar( interp, argv[1+0], buf, 0 );
516  else
517  Tcl_AppendResult( interp, buf, (char *) NULL );
518  if (argc == 1)
519  Tcl_AppendResult( interp, " ", (char *) NULL );
520  sprintf( buf, "%d", month );
521  if (argc > 1)
522  Tcl_SetVar( interp, argv[1+1], buf, 0 );
523  else
524  Tcl_AppendResult( interp, buf, (char *) NULL );
525  if (argc == 1)
526  Tcl_AppendResult( interp, " ", (char *) NULL );
527  sprintf( buf, "%d", day );
528  if (argc > 1)
529  Tcl_SetVar( interp, argv[1+2], buf, 0 );
530  else
531  Tcl_AppendResult( interp, buf, (char *) NULL );
532  if (argc == 1)
533  Tcl_AppendResult( interp, " ", (char *) NULL );
534  sprintf( buf, "%d", hour );
535  if (argc > 1)
536  Tcl_SetVar( interp, argv[1+3], buf, 0 );
537  else
538  Tcl_AppendResult( interp, buf, (char *) NULL );
539  if (argc == 1)
540  Tcl_AppendResult( interp, " ", (char *) NULL );
541  sprintf( buf, "%d", min );
542  if (argc > 1)
543  Tcl_SetVar( interp, argv[1+4], buf, 0 );
544  else
545  Tcl_AppendResult( interp, buf, (char *) NULL );
546  if (argc == 1)
547  Tcl_AppendResult( interp, " ", (char *) NULL );
548  Tcl_PrintDouble( interp, sec, buf );
549  if (argc > 1)
550  Tcl_SetVar( interp, argv[1+5], buf, 0 );
551  else
552  Tcl_AppendResult( interp, buf, (char *) NULL );
553 
554  if (pl_errcode != 0) {
555  Tcl_AppendResult(interp, errmsg, (char *) NULL);
556  return TCL_ERROR;
557  }
558 
559  plflush();
560  return TCL_OK;
561 }
562 
563 /*--------------------------------------------------------------------------*\
564  * plcalc_worldCmd
565  *
566  * Processes plcalc_world Tcl command.
567 \*--------------------------------------------------------------------------*/
568 
569 static int
570 plcalc_worldCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
571 {
572  PLFLT rx;
573  PLFLT ry;
574  PLFLT wx;
575  PLFLT wy;
576  PLINT window;
577 
578  pl_errcode = 0; errmsg[0] = '\0';
579 
580  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
581  Tcl_AppendResult( interp, "command syntax: \"",
582  "plcalc_world ?rx ry wx wy window?", "\"",
583  (char *) NULL);
584  return TCL_ERROR;
585  }
586 
587  if ( (!1 && 0 && (argc < (1 + 5 - 0))) ||
588  (!1 && !0 && (argc != (5 + 1))) ||
589  ( 1 && (argc != 1) && (argc != (5 + 1))) ) {
590  Tcl_AppendResult( interp, "wrong # args: should be \"",
591  "plcalc_world ?rx ry wx wy window?", "\"",
592  (char *) NULL);
593  return TCL_ERROR;
594  }
595 
596  rx = atof(argv[1+0]);
597  ry = atof(argv[1+1]);
598 /* wx is for output. */
599 /* wy is for output. */
600 /* window is for output. */
601 
602  plcalc_world ( rx, ry, &wx, &wy, &window );
603 
604  if (argc == 1)
605  Tcl_AppendResult( interp, " ", (char *) NULL );
606  Tcl_PrintDouble( interp, wx, buf );
607  if (argc > 1)
608  Tcl_SetVar( interp, argv[1+2], buf, 0 );
609  else
610  Tcl_AppendResult( interp, buf, (char *) NULL );
611  if (argc == 1)
612  Tcl_AppendResult( interp, " ", (char *) NULL );
613  Tcl_PrintDouble( interp, wy, buf );
614  if (argc > 1)
615  Tcl_SetVar( interp, argv[1+3], buf, 0 );
616  else
617  Tcl_AppendResult( interp, buf, (char *) NULL );
618  if (argc == 1)
619  Tcl_AppendResult( interp, " ", (char *) NULL );
620  sprintf( buf, "%d", window );
621  if (argc > 1)
622  Tcl_SetVar( interp, argv[1+4], buf, 0 );
623  else
624  Tcl_AppendResult( interp, buf, (char *) NULL );
625 
626  if (pl_errcode != 0) {
627  Tcl_AppendResult(interp, errmsg, (char *) NULL);
628  return TCL_ERROR;
629  }
630 
631  plflush();
632  return TCL_OK;
633 }
634 
635 /*--------------------------------------------------------------------------*\
636  * plclearCmd
637  *
638  * Processes plclear Tcl command.
639 \*--------------------------------------------------------------------------*/
640 
641 static int
642 plclearCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
643 {
644 
645  pl_errcode = 0; errmsg[0] = '\0';
646 
647  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
648  Tcl_AppendResult( interp, "command syntax: \"",
649  "plclear ", "\"",
650  (char *) NULL);
651  return TCL_ERROR;
652  }
653 
654  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
655  (!0 && !0 && (argc != (0 + 1))) ||
656  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
657  Tcl_AppendResult( interp, "wrong # args: should be \"",
658  "plclear ", "\"",
659  (char *) NULL);
660  return TCL_ERROR;
661  }
662 
663 
664  plclear ( );
665 
666 
667  if (pl_errcode != 0) {
668  Tcl_AppendResult(interp, errmsg, (char *) NULL);
669  return TCL_ERROR;
670  }
671 
672  plflush();
673  return TCL_OK;
674 }
675 
676 /*--------------------------------------------------------------------------*\
677  * plcol0Cmd
678  *
679  * Processes plcol0 Tcl command.
680 \*--------------------------------------------------------------------------*/
681 
682 static int
683 plcol0Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
684 {
685  PLINT icol0;
686 
687  pl_errcode = 0; errmsg[0] = '\0';
688 
689  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
690  Tcl_AppendResult( interp, "command syntax: \"",
691  "plcol0 icol0", "\"",
692  (char *) NULL);
693  return TCL_ERROR;
694  }
695 
696  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
697  (!0 && !0 && (argc != (1 + 1))) ||
698  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
699  Tcl_AppendResult( interp, "wrong # args: should be \"",
700  "plcol0 icol0", "\"",
701  (char *) NULL);
702  return TCL_ERROR;
703  }
704 
705  icol0 = atoi(argv[1+0]);
706 
707  plcol0 ( icol0 );
708 
709 
710  if (pl_errcode != 0) {
711  Tcl_AppendResult(interp, errmsg, (char *) NULL);
712  return TCL_ERROR;
713  }
714 
715  plflush();
716  return TCL_OK;
717 }
718 
719 /*--------------------------------------------------------------------------*\
720  * plcol1Cmd
721  *
722  * Processes plcol1 Tcl command.
723 \*--------------------------------------------------------------------------*/
724 
725 static int
726 plcol1Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
727 {
728  PLFLT col1;
729 
730  pl_errcode = 0; errmsg[0] = '\0';
731 
732  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
733  Tcl_AppendResult( interp, "command syntax: \"",
734  "plcol1 col1", "\"",
735  (char *) NULL);
736  return TCL_ERROR;
737  }
738 
739  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
740  (!0 && !0 && (argc != (1 + 1))) ||
741  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
742  Tcl_AppendResult( interp, "wrong # args: should be \"",
743  "plcol1 col1", "\"",
744  (char *) NULL);
745  return TCL_ERROR;
746  }
747 
748  col1 = atof(argv[1+0]);
749 
750  plcol1 ( col1 );
751 
752 
753  if (pl_errcode != 0) {
754  Tcl_AppendResult(interp, errmsg, (char *) NULL);
755  return TCL_ERROR;
756  }
757 
758  plflush();
759  return TCL_OK;
760 }
761 
762 /*--------------------------------------------------------------------------*\
763  * plconfigtimeCmd
764  *
765  * Processes plconfigtime Tcl command.
766 \*--------------------------------------------------------------------------*/
767 
768 static int
769 plconfigtimeCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
770 {
771  PLFLT scale;
772  PLFLT offset1;
773  PLFLT offset2;
774  PLINT ccontrol;
775  PLINT ifbtime_offset;
776  PLINT year;
777  PLINT month;
778  PLINT day;
779  PLINT hour;
780  PLINT min;
781  PLFLT sec;
782 
783  pl_errcode = 0; errmsg[0] = '\0';
784 
785  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
786  Tcl_AppendResult( interp, "command syntax: \"",
787  "plconfigtime scale offset1 offset2 ccontrol ifbtime_offset year month day hour min sec", "\"",
788  (char *) NULL);
789  return TCL_ERROR;
790  }
791 
792  if ( (!0 && 0 && (argc < (1 + 11 - 0))) ||
793  (!0 && !0 && (argc != (11 + 1))) ||
794  ( 0 && (argc != 1) && (argc != (11 + 1))) ) {
795  Tcl_AppendResult( interp, "wrong # args: should be \"",
796  "plconfigtime scale offset1 offset2 ccontrol ifbtime_offset year month day hour min sec", "\"",
797  (char *) NULL);
798  return TCL_ERROR;
799  }
800 
801  scale = atof(argv[1+0]);
802  offset1 = atof(argv[1+1]);
803  offset2 = atof(argv[1+2]);
804  ccontrol = atoi(argv[1+3]);
805  ifbtime_offset = atoi(argv[1+4]);
806  year = atoi(argv[1+5]);
807  month = atoi(argv[1+6]);
808  day = atoi(argv[1+7]);
809  hour = atoi(argv[1+8]);
810  min = atoi(argv[1+9]);
811  sec = atof(argv[1+10]);
812 
813  plconfigtime ( scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec );
814 
815 
816  if (pl_errcode != 0) {
817  Tcl_AppendResult(interp, errmsg, (char *) NULL);
818  return TCL_ERROR;
819  }
820 
821  plflush();
822  return TCL_OK;
823 }
824 
825 /*--------------------------------------------------------------------------*\
826  * plcpstrmCmd
827  *
828  * Processes plcpstrm Tcl command.
829 \*--------------------------------------------------------------------------*/
830 
831 static int
832 plcpstrmCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
833 {
834  PLINT iplsr;
835  PLINT flags;
836 
837  pl_errcode = 0; errmsg[0] = '\0';
838 
839  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
840  Tcl_AppendResult( interp, "command syntax: \"",
841  "plcpstrm iplsr flags", "\"",
842  (char *) NULL);
843  return TCL_ERROR;
844  }
845 
846  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
847  (!0 && !0 && (argc != (2 + 1))) ||
848  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
849  Tcl_AppendResult( interp, "wrong # args: should be \"",
850  "plcpstrm iplsr flags", "\"",
851  (char *) NULL);
852  return TCL_ERROR;
853  }
854 
855  iplsr = atoi(argv[1+0]);
856  flags = atoi(argv[1+1]);
857 
858  plcpstrm ( iplsr, flags );
859 
860 
861  if (pl_errcode != 0) {
862  Tcl_AppendResult(interp, errmsg, (char *) NULL);
863  return TCL_ERROR;
864  }
865 
866  plflush();
867  return TCL_OK;
868 }
869 
870 /*--------------------------------------------------------------------------*\
871  * plctimeCmd
872  *
873  * Processes plctime Tcl command.
874 \*--------------------------------------------------------------------------*/
875 
876 static int
877 plctimeCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
878 {
879  PLINT year;
880  PLINT month;
881  PLINT day;
882  PLINT hour;
883  PLINT min;
884  PLFLT sec;
885  PLFLT ctime;
886 
887  pl_errcode = 0; errmsg[0] = '\0';
888 
889  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
890  Tcl_AppendResult( interp, "command syntax: \"",
891  "plctime ?year month day hour min sec ctime?", "\"",
892  (char *) NULL);
893  return TCL_ERROR;
894  }
895 
896  if ( (!1 && 0 && (argc < (1 + 7 - 0))) ||
897  (!1 && !0 && (argc != (7 + 1))) ||
898  ( 1 && (argc != 1) && (argc != (7 + 1))) ) {
899  Tcl_AppendResult( interp, "wrong # args: should be \"",
900  "plctime ?year month day hour min sec ctime?", "\"",
901  (char *) NULL);
902  return TCL_ERROR;
903  }
904 
905  year = atoi(argv[1+0]);
906  month = atoi(argv[1+1]);
907  day = atoi(argv[1+2]);
908  hour = atoi(argv[1+3]);
909  min = atoi(argv[1+4]);
910  sec = atof(argv[1+5]);
911 /* ctime is for output. */
912 
913  plctime ( year, month, day, hour, min, sec, &ctime );
914 
915  if (argc == 1)
916  Tcl_AppendResult( interp, " ", (char *) NULL );
917  Tcl_PrintDouble( interp, ctime, buf );
918  if (argc > 1)
919  Tcl_SetVar( interp, argv[1+6], buf, 0 );
920  else
921  Tcl_AppendResult( interp, buf, (char *) NULL );
922 
923  if (pl_errcode != 0) {
924  Tcl_AppendResult(interp, errmsg, (char *) NULL);
925  return TCL_ERROR;
926  }
927 
928  plflush();
929  return TCL_OK;
930 }
931 
932 /*--------------------------------------------------------------------------*\
933  * pldid2pcCmd
934  *
935  * Processes pldid2pc Tcl command.
936 \*--------------------------------------------------------------------------*/
937 
938 static int
939 pldid2pcCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
940 {
941  PLFLT xmin;
942  PLFLT ymin;
943  PLFLT xmax;
944  PLFLT ymax;
945 
946  pl_errcode = 0; errmsg[0] = '\0';
947 
948  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
949  Tcl_AppendResult( interp, "command syntax: \"",
950  "pldid2pc ?xmin ymin xmax ymax?", "\"",
951  (char *) NULL);
952  return TCL_ERROR;
953  }
954 
955  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
956  (!1 && !0 && (argc != (4 + 1))) ||
957  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
958  Tcl_AppendResult( interp, "wrong # args: should be \"",
959  "pldid2pc ?xmin ymin xmax ymax?", "\"",
960  (char *) NULL);
961  return TCL_ERROR;
962  }
963 
964 /* xmin is for output. */
965 /* ymin is for output. */
966 /* xmax is for output. */
967 /* ymax is for output. */
968 
969  pldid2pc ( &xmin, &ymin, &xmax, &ymax );
970 
971  Tcl_PrintDouble( interp, xmin, buf );
972  if (argc > 1)
973  Tcl_SetVar( interp, argv[1+0], buf, 0 );
974  else
975  Tcl_AppendResult( interp, buf, (char *) NULL );
976  if (argc == 1)
977  Tcl_AppendResult( interp, " ", (char *) NULL );
978  Tcl_PrintDouble( interp, ymin, buf );
979  if (argc > 1)
980  Tcl_SetVar( interp, argv[1+1], buf, 0 );
981  else
982  Tcl_AppendResult( interp, buf, (char *) NULL );
983  if (argc == 1)
984  Tcl_AppendResult( interp, " ", (char *) NULL );
985  Tcl_PrintDouble( interp, xmax, buf );
986  if (argc > 1)
987  Tcl_SetVar( interp, argv[1+2], buf, 0 );
988  else
989  Tcl_AppendResult( interp, buf, (char *) NULL );
990  if (argc == 1)
991  Tcl_AppendResult( interp, " ", (char *) NULL );
992  Tcl_PrintDouble( interp, ymax, buf );
993  if (argc > 1)
994  Tcl_SetVar( interp, argv[1+3], buf, 0 );
995  else
996  Tcl_AppendResult( interp, buf, (char *) NULL );
997 
998  if (pl_errcode != 0) {
999  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1000  return TCL_ERROR;
1001  }
1002 
1003  plflush();
1004  return TCL_OK;
1005 }
1006 
1007 /*--------------------------------------------------------------------------*\
1008  * pldip2dcCmd
1009  *
1010  * Processes pldip2dc Tcl command.
1011 \*--------------------------------------------------------------------------*/
1012 
1013 static int
1014 pldip2dcCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1015 {
1016  PLFLT xmin;
1017  PLFLT ymin;
1018  PLFLT xmax;
1019  PLFLT ymax;
1020 
1021  pl_errcode = 0; errmsg[0] = '\0';
1022 
1023  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1024  Tcl_AppendResult( interp, "command syntax: \"",
1025  "pldip2dc ?xmin ymin xmax ymax?", "\"",
1026  (char *) NULL);
1027  return TCL_ERROR;
1028  }
1029 
1030  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
1031  (!1 && !0 && (argc != (4 + 1))) ||
1032  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
1033  Tcl_AppendResult( interp, "wrong # args: should be \"",
1034  "pldip2dc ?xmin ymin xmax ymax?", "\"",
1035  (char *) NULL);
1036  return TCL_ERROR;
1037  }
1038 
1039 /* xmin is for output. */
1040 /* ymin is for output. */
1041 /* xmax is for output. */
1042 /* ymax is for output. */
1043 
1044  pldip2dc ( &xmin, &ymin, &xmax, &ymax );
1045 
1046  Tcl_PrintDouble( interp, xmin, buf );
1047  if (argc > 1)
1048  Tcl_SetVar( interp, argv[1+0], buf, 0 );
1049  else
1050  Tcl_AppendResult( interp, buf, (char *) NULL );
1051  if (argc == 1)
1052  Tcl_AppendResult( interp, " ", (char *) NULL );
1053  Tcl_PrintDouble( interp, ymin, buf );
1054  if (argc > 1)
1055  Tcl_SetVar( interp, argv[1+1], buf, 0 );
1056  else
1057  Tcl_AppendResult( interp, buf, (char *) NULL );
1058  if (argc == 1)
1059  Tcl_AppendResult( interp, " ", (char *) NULL );
1060  Tcl_PrintDouble( interp, xmax, buf );
1061  if (argc > 1)
1062  Tcl_SetVar( interp, argv[1+2], buf, 0 );
1063  else
1064  Tcl_AppendResult( interp, buf, (char *) NULL );
1065  if (argc == 1)
1066  Tcl_AppendResult( interp, " ", (char *) NULL );
1067  Tcl_PrintDouble( interp, ymax, buf );
1068  if (argc > 1)
1069  Tcl_SetVar( interp, argv[1+3], buf, 0 );
1070  else
1071  Tcl_AppendResult( interp, buf, (char *) NULL );
1072 
1073  if (pl_errcode != 0) {
1074  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1075  return TCL_ERROR;
1076  }
1077 
1078  plflush();
1079  return TCL_OK;
1080 }
1081 
1082 /*--------------------------------------------------------------------------*\
1083  * plendCmd
1084  *
1085  * Processes plend Tcl command.
1086 \*--------------------------------------------------------------------------*/
1087 
1088 static int
1089 plendCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1090 {
1091 
1092  pl_errcode = 0; errmsg[0] = '\0';
1093 
1094  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1095  Tcl_AppendResult( interp, "command syntax: \"",
1096  "plend ", "\"",
1097  (char *) NULL);
1098  return TCL_ERROR;
1099  }
1100 
1101  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
1102  (!0 && !0 && (argc != (0 + 1))) ||
1103  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
1104  Tcl_AppendResult( interp, "wrong # args: should be \"",
1105  "plend ", "\"",
1106  (char *) NULL);
1107  return TCL_ERROR;
1108  }
1109 
1110 
1111  plend ( );
1112 
1113 
1114  if (pl_errcode != 0) {
1115  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1116  return TCL_ERROR;
1117  }
1118 
1119  plflush();
1120  return TCL_OK;
1121 }
1122 
1123 /*--------------------------------------------------------------------------*\
1124  * plend1Cmd
1125  *
1126  * Processes plend1 Tcl command.
1127 \*--------------------------------------------------------------------------*/
1128 
1129 static int
1130 plend1Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1131 {
1132 
1133  pl_errcode = 0; errmsg[0] = '\0';
1134 
1135  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1136  Tcl_AppendResult( interp, "command syntax: \"",
1137  "plend1 ", "\"",
1138  (char *) NULL);
1139  return TCL_ERROR;
1140  }
1141 
1142  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
1143  (!0 && !0 && (argc != (0 + 1))) ||
1144  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
1145  Tcl_AppendResult( interp, "wrong # args: should be \"",
1146  "plend1 ", "\"",
1147  (char *) NULL);
1148  return TCL_ERROR;
1149  }
1150 
1151 
1152  plend1 ( );
1153 
1154 
1155  if (pl_errcode != 0) {
1156  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1157  return TCL_ERROR;
1158  }
1159 
1160  plflush();
1161  return TCL_OK;
1162 }
1163 
1164 /*--------------------------------------------------------------------------*\
1165  * plenvCmd
1166  *
1167  * Processes plenv Tcl command.
1168 \*--------------------------------------------------------------------------*/
1169 
1170 static int
1171 plenvCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1172 {
1173  PLFLT xmin;
1174  PLFLT xmax;
1175  PLFLT ymin;
1176  PLFLT ymax;
1177  PLINT just;
1178  PLINT axis;
1179 
1180  pl_errcode = 0; errmsg[0] = '\0';
1181 
1182  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1183  Tcl_AppendResult( interp, "command syntax: \"",
1184  "plenv xmin xmax ymin ymax just axis", "\"",
1185  (char *) NULL);
1186  return TCL_ERROR;
1187  }
1188 
1189  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
1190  (!0 && !0 && (argc != (6 + 1))) ||
1191  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
1192  Tcl_AppendResult( interp, "wrong # args: should be \"",
1193  "plenv xmin xmax ymin ymax just axis", "\"",
1194  (char *) NULL);
1195  return TCL_ERROR;
1196  }
1197 
1198  xmin = atof(argv[1+0]);
1199  xmax = atof(argv[1+1]);
1200  ymin = atof(argv[1+2]);
1201  ymax = atof(argv[1+3]);
1202  just = atoi(argv[1+4]);
1203  axis = atoi(argv[1+5]);
1204 
1205  plenv ( xmin, xmax, ymin, ymax, just, axis );
1206 
1207 
1208  if (pl_errcode != 0) {
1209  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1210  return TCL_ERROR;
1211  }
1212 
1213  plflush();
1214  return TCL_OK;
1215 }
1216 
1217 /*--------------------------------------------------------------------------*\
1218  * plenv0Cmd
1219  *
1220  * Processes plenv0 Tcl command.
1221 \*--------------------------------------------------------------------------*/
1222 
1223 static int
1224 plenv0Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1225 {
1226  PLFLT xmin;
1227  PLFLT xmax;
1228  PLFLT ymin;
1229  PLFLT ymax;
1230  PLINT just;
1231  PLINT axis;
1232 
1233  pl_errcode = 0; errmsg[0] = '\0';
1234 
1235  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1236  Tcl_AppendResult( interp, "command syntax: \"",
1237  "plenv0 xmin xmax ymin ymax just axis", "\"",
1238  (char *) NULL);
1239  return TCL_ERROR;
1240  }
1241 
1242  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
1243  (!0 && !0 && (argc != (6 + 1))) ||
1244  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
1245  Tcl_AppendResult( interp, "wrong # args: should be \"",
1246  "plenv0 xmin xmax ymin ymax just axis", "\"",
1247  (char *) NULL);
1248  return TCL_ERROR;
1249  }
1250 
1251  xmin = atof(argv[1+0]);
1252  xmax = atof(argv[1+1]);
1253  ymin = atof(argv[1+2]);
1254  ymax = atof(argv[1+3]);
1255  just = atoi(argv[1+4]);
1256  axis = atoi(argv[1+5]);
1257 
1258  plenv0 ( xmin, xmax, ymin, ymax, just, axis );
1259 
1260 
1261  if (pl_errcode != 0) {
1262  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1263  return TCL_ERROR;
1264  }
1265 
1266  plflush();
1267  return TCL_OK;
1268 }
1269 
1270 /*--------------------------------------------------------------------------*\
1271  * pleopCmd
1272  *
1273  * Processes pleop Tcl command.
1274 \*--------------------------------------------------------------------------*/
1275 
1276 static int
1277 pleopCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1278 {
1279 
1280  pl_errcode = 0; errmsg[0] = '\0';
1281 
1282  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1283  Tcl_AppendResult( interp, "command syntax: \"",
1284  "pleop ", "\"",
1285  (char *) NULL);
1286  return TCL_ERROR;
1287  }
1288 
1289  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
1290  (!0 && !0 && (argc != (0 + 1))) ||
1291  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
1292  Tcl_AppendResult( interp, "wrong # args: should be \"",
1293  "pleop ", "\"",
1294  (char *) NULL);
1295  return TCL_ERROR;
1296  }
1297 
1298 
1299  pleop ( );
1300 
1301 
1302  if (pl_errcode != 0) {
1303  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1304  return TCL_ERROR;
1305  }
1306 
1307  plflush();
1308  return TCL_OK;
1309 }
1310 
1311 /*--------------------------------------------------------------------------*\
1312  * plerrxCmd
1313  *
1314  * Processes plerrx Tcl command.
1315 \*--------------------------------------------------------------------------*/
1316 
1317 static int
1318 plerrxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1319 {
1320  PLINT n;
1321  PLFLT *xmin;
1322  tclMatrix *matxmin;
1323  PLFLT *xmax;
1324  tclMatrix *matxmax;
1325  PLFLT *y;
1326  tclMatrix *maty;
1327 
1328  pl_errcode = 0; errmsg[0] = '\0';
1329 
1330  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1331  Tcl_AppendResult( interp, "command syntax: \"",
1332  "plerrx n xmin xmax y", "\"",
1333  (char *) NULL);
1334  return TCL_ERROR;
1335  }
1336 
1337  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
1338  (!0 && !0 && (argc != (4 + 1))) ||
1339  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
1340  Tcl_AppendResult( interp, "wrong # args: should be \"",
1341  "plerrx n xmin xmax y", "\"",
1342  (char *) NULL);
1343  return TCL_ERROR;
1344  }
1345 
1346  n = atoi(argv[1+0]);
1347  matxmin = Tcl_GetMatrixPtr( interp, argv[1+1] );
1348  if (matxmin == NULL) return TCL_ERROR;
1349  xmin = matxmin->fdata;
1350  matxmax = Tcl_GetMatrixPtr( interp, argv[1+2] );
1351  if (matxmax == NULL) return TCL_ERROR;
1352  xmax = matxmax->fdata;
1353  maty = Tcl_GetMatrixPtr( interp, argv[1+3] );
1354  if (maty == NULL) return TCL_ERROR;
1355  y = maty->fdata;
1356 
1357  plerrx ( n, xmin, xmax, y );
1358 
1359 
1360  if (pl_errcode != 0) {
1361  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1362  return TCL_ERROR;
1363  }
1364 
1365  plflush();
1366  return TCL_OK;
1367 }
1368 
1369 /*--------------------------------------------------------------------------*\
1370  * plerryCmd
1371  *
1372  * Processes plerry Tcl command.
1373 \*--------------------------------------------------------------------------*/
1374 
1375 static int
1376 plerryCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1377 {
1378  PLINT n;
1379  PLFLT *x;
1380  tclMatrix *matx;
1381  PLFLT *ymin;
1382  tclMatrix *matymin;
1383  PLFLT *ymax;
1384  tclMatrix *matymax;
1385 
1386  pl_errcode = 0; errmsg[0] = '\0';
1387 
1388  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1389  Tcl_AppendResult( interp, "command syntax: \"",
1390  "plerry n x ymin ymax", "\"",
1391  (char *) NULL);
1392  return TCL_ERROR;
1393  }
1394 
1395  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
1396  (!0 && !0 && (argc != (4 + 1))) ||
1397  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
1398  Tcl_AppendResult( interp, "wrong # args: should be \"",
1399  "plerry n x ymin ymax", "\"",
1400  (char *) NULL);
1401  return TCL_ERROR;
1402  }
1403 
1404  n = atoi(argv[1+0]);
1405  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
1406  if (matx == NULL) return TCL_ERROR;
1407  x = matx->fdata;
1408  matymin = Tcl_GetMatrixPtr( interp, argv[1+2] );
1409  if (matymin == NULL) return TCL_ERROR;
1410  ymin = matymin->fdata;
1411  matymax = Tcl_GetMatrixPtr( interp, argv[1+3] );
1412  if (matymax == NULL) return TCL_ERROR;
1413  ymax = matymax->fdata;
1414 
1415  plerry ( n, x, ymin, ymax );
1416 
1417 
1418  if (pl_errcode != 0) {
1419  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1420  return TCL_ERROR;
1421  }
1422 
1423  plflush();
1424  return TCL_OK;
1425 }
1426 
1427 /*--------------------------------------------------------------------------*\
1428  * plfamadvCmd
1429  *
1430  * Processes plfamadv Tcl command.
1431 \*--------------------------------------------------------------------------*/
1432 
1433 static int
1434 plfamadvCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1435 {
1436 
1437  pl_errcode = 0; errmsg[0] = '\0';
1438 
1439  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1440  Tcl_AppendResult( interp, "command syntax: \"",
1441  "plfamadv ", "\"",
1442  (char *) NULL);
1443  return TCL_ERROR;
1444  }
1445 
1446  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
1447  (!0 && !0 && (argc != (0 + 1))) ||
1448  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
1449  Tcl_AppendResult( interp, "wrong # args: should be \"",
1450  "plfamadv ", "\"",
1451  (char *) NULL);
1452  return TCL_ERROR;
1453  }
1454 
1455 
1456  plfamadv ( );
1457 
1458 
1459  if (pl_errcode != 0) {
1460  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1461  return TCL_ERROR;
1462  }
1463 
1464  plflush();
1465  return TCL_OK;
1466 }
1467 
1468 /*--------------------------------------------------------------------------*\
1469  * plfillCmd
1470  *
1471  * Processes plfill Tcl command.
1472 \*--------------------------------------------------------------------------*/
1473 
1474 static int
1475 plfillCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1476 {
1477  PLINT n;
1478  PLFLT *x;
1479  tclMatrix *matx;
1480  PLFLT *y;
1481  tclMatrix *maty;
1482 
1483  pl_errcode = 0; errmsg[0] = '\0';
1484 
1485  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1486  Tcl_AppendResult( interp, "command syntax: \"",
1487  "plfill n x y", "\"",
1488  (char *) NULL);
1489  return TCL_ERROR;
1490  }
1491 
1492  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
1493  (!0 && !0 && (argc != (3 + 1))) ||
1494  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
1495  Tcl_AppendResult( interp, "wrong # args: should be \"",
1496  "plfill n x y", "\"",
1497  (char *) NULL);
1498  return TCL_ERROR;
1499  }
1500 
1501  n = atoi(argv[1+0]);
1502  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
1503  if (matx == NULL) return TCL_ERROR;
1504  x = matx->fdata;
1505  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
1506  if (maty == NULL) return TCL_ERROR;
1507  y = maty->fdata;
1508 
1509  plfill ( n, x, y );
1510 
1511 
1512  if (pl_errcode != 0) {
1513  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1514  return TCL_ERROR;
1515  }
1516 
1517  plflush();
1518  return TCL_OK;
1519 }
1520 
1521 /*--------------------------------------------------------------------------*\
1522  * plfill3Cmd
1523  *
1524  * Processes plfill3 Tcl command.
1525 \*--------------------------------------------------------------------------*/
1526 
1527 static int
1528 plfill3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1529 {
1530  PLINT n;
1531  PLFLT *x;
1532  tclMatrix *matx;
1533  PLFLT *y;
1534  tclMatrix *maty;
1535  PLFLT *z;
1536  tclMatrix *matz;
1537 
1538  pl_errcode = 0; errmsg[0] = '\0';
1539 
1540  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1541  Tcl_AppendResult( interp, "command syntax: \"",
1542  "plfill3 n x y z", "\"",
1543  (char *) NULL);
1544  return TCL_ERROR;
1545  }
1546 
1547  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
1548  (!0 && !0 && (argc != (4 + 1))) ||
1549  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
1550  Tcl_AppendResult( interp, "wrong # args: should be \"",
1551  "plfill3 n x y z", "\"",
1552  (char *) NULL);
1553  return TCL_ERROR;
1554  }
1555 
1556  n = atoi(argv[1+0]);
1557  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
1558  if (matx == NULL) return TCL_ERROR;
1559  x = matx->fdata;
1560  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
1561  if (maty == NULL) return TCL_ERROR;
1562  y = maty->fdata;
1563  matz = Tcl_GetMatrixPtr( interp, argv[1+3] );
1564  if (matz == NULL) return TCL_ERROR;
1565  z = matz->fdata;
1566 
1567  plfill3 ( n, x, y, z );
1568 
1569 
1570  if (pl_errcode != 0) {
1571  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1572  return TCL_ERROR;
1573  }
1574 
1575  plflush();
1576  return TCL_OK;
1577 }
1578 
1579 /*--------------------------------------------------------------------------*\
1580  * plflushCmd
1581  *
1582  * Processes plflush Tcl command.
1583 \*--------------------------------------------------------------------------*/
1584 
1585 static int
1586 plflushCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1587 {
1588 
1589  pl_errcode = 0; errmsg[0] = '\0';
1590 
1591  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1592  Tcl_AppendResult( interp, "command syntax: \"",
1593  "plflush ", "\"",
1594  (char *) NULL);
1595  return TCL_ERROR;
1596  }
1597 
1598  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
1599  (!0 && !0 && (argc != (0 + 1))) ||
1600  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
1601  Tcl_AppendResult( interp, "wrong # args: should be \"",
1602  "plflush ", "\"",
1603  (char *) NULL);
1604  return TCL_ERROR;
1605  }
1606 
1607 
1608  plflush ( );
1609 
1610 
1611  if (pl_errcode != 0) {
1612  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1613  return TCL_ERROR;
1614  }
1615 
1616  plflush();
1617  return TCL_OK;
1618 }
1619 
1620 /*--------------------------------------------------------------------------*\
1621  * plfontCmd
1622  *
1623  * Processes plfont Tcl command.
1624 \*--------------------------------------------------------------------------*/
1625 
1626 static int
1627 plfontCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1628 {
1629  PLINT ifont;
1630 
1631  pl_errcode = 0; errmsg[0] = '\0';
1632 
1633  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1634  Tcl_AppendResult( interp, "command syntax: \"",
1635  "plfont ifont", "\"",
1636  (char *) NULL);
1637  return TCL_ERROR;
1638  }
1639 
1640  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
1641  (!0 && !0 && (argc != (1 + 1))) ||
1642  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
1643  Tcl_AppendResult( interp, "wrong # args: should be \"",
1644  "plfont ifont", "\"",
1645  (char *) NULL);
1646  return TCL_ERROR;
1647  }
1648 
1649  ifont = atoi(argv[1+0]);
1650 
1651  plfont ( ifont );
1652 
1653 
1654  if (pl_errcode != 0) {
1655  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1656  return TCL_ERROR;
1657  }
1658 
1659  plflush();
1660  return TCL_OK;
1661 }
1662 
1663 /*--------------------------------------------------------------------------*\
1664  * plfontldCmd
1665  *
1666  * Processes plfontld Tcl command.
1667 \*--------------------------------------------------------------------------*/
1668 
1669 static int
1670 plfontldCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1671 {
1672  PLINT fnt;
1673 
1674  pl_errcode = 0; errmsg[0] = '\0';
1675 
1676  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1677  Tcl_AppendResult( interp, "command syntax: \"",
1678  "plfontld fnt", "\"",
1679  (char *) NULL);
1680  return TCL_ERROR;
1681  }
1682 
1683  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
1684  (!0 && !0 && (argc != (1 + 1))) ||
1685  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
1686  Tcl_AppendResult( interp, "wrong # args: should be \"",
1687  "plfontld fnt", "\"",
1688  (char *) NULL);
1689  return TCL_ERROR;
1690  }
1691 
1692  fnt = atoi(argv[1+0]);
1693 
1694  plfontld ( fnt );
1695 
1696 
1697  if (pl_errcode != 0) {
1698  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1699  return TCL_ERROR;
1700  }
1701 
1702  plflush();
1703  return TCL_OK;
1704 }
1705 
1706 /*--------------------------------------------------------------------------*\
1707  * plgchrCmd
1708  *
1709  * Processes plgchr Tcl command.
1710 \*--------------------------------------------------------------------------*/
1711 
1712 static int
1713 plgchrCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1714 {
1715  PLFLT def;
1716  PLFLT ht;
1717 
1718  pl_errcode = 0; errmsg[0] = '\0';
1719 
1720  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1721  Tcl_AppendResult( interp, "command syntax: \"",
1722  "plgchr ?def ht?", "\"",
1723  (char *) NULL);
1724  return TCL_ERROR;
1725  }
1726 
1727  if ( (!1 && 0 && (argc < (1 + 2 - 0))) ||
1728  (!1 && !0 && (argc != (2 + 1))) ||
1729  ( 1 && (argc != 1) && (argc != (2 + 1))) ) {
1730  Tcl_AppendResult( interp, "wrong # args: should be \"",
1731  "plgchr ?def ht?", "\"",
1732  (char *) NULL);
1733  return TCL_ERROR;
1734  }
1735 
1736 /* def is for output. */
1737 /* ht is for output. */
1738 
1739  plgchr ( &def, &ht );
1740 
1741  Tcl_PrintDouble( interp, def, buf );
1742  if (argc > 1)
1743  Tcl_SetVar( interp, argv[1+0], buf, 0 );
1744  else
1745  Tcl_AppendResult( interp, buf, (char *) NULL );
1746  if (argc == 1)
1747  Tcl_AppendResult( interp, " ", (char *) NULL );
1748  Tcl_PrintDouble( interp, ht, buf );
1749  if (argc > 1)
1750  Tcl_SetVar( interp, argv[1+1], buf, 0 );
1751  else
1752  Tcl_AppendResult( interp, buf, (char *) NULL );
1753 
1754  if (pl_errcode != 0) {
1755  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1756  return TCL_ERROR;
1757  }
1758 
1759  plflush();
1760  return TCL_OK;
1761 }
1762 
1763 /*--------------------------------------------------------------------------*\
1764  * plgcmap1_rangeCmd
1765  *
1766  * Processes plgcmap1_range Tcl command.
1767 \*--------------------------------------------------------------------------*/
1768 
1769 static int
1770 plgcmap1_rangeCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1771 {
1772  PLFLT min_color;
1773  PLFLT max_color;
1774 
1775  pl_errcode = 0; errmsg[0] = '\0';
1776 
1777  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1778  Tcl_AppendResult( interp, "command syntax: \"",
1779  "plgcmap1_range ?min_color max_color?", "\"",
1780  (char *) NULL);
1781  return TCL_ERROR;
1782  }
1783 
1784  if ( (!1 && 0 && (argc < (1 + 2 - 0))) ||
1785  (!1 && !0 && (argc != (2 + 1))) ||
1786  ( 1 && (argc != 1) && (argc != (2 + 1))) ) {
1787  Tcl_AppendResult( interp, "wrong # args: should be \"",
1788  "plgcmap1_range ?min_color max_color?", "\"",
1789  (char *) NULL);
1790  return TCL_ERROR;
1791  }
1792 
1793 /* min_color is for output. */
1794 /* max_color is for output. */
1795 
1796  plgcmap1_range ( &min_color, &max_color );
1797 
1798  Tcl_PrintDouble( interp, min_color, buf );
1799  if (argc > 1)
1800  Tcl_SetVar( interp, argv[1+0], buf, 0 );
1801  else
1802  Tcl_AppendResult( interp, buf, (char *) NULL );
1803  if (argc == 1)
1804  Tcl_AppendResult( interp, " ", (char *) NULL );
1805  Tcl_PrintDouble( interp, max_color, buf );
1806  if (argc > 1)
1807  Tcl_SetVar( interp, argv[1+1], buf, 0 );
1808  else
1809  Tcl_AppendResult( interp, buf, (char *) NULL );
1810 
1811  if (pl_errcode != 0) {
1812  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1813  return TCL_ERROR;
1814  }
1815 
1816  plflush();
1817  return TCL_OK;
1818 }
1819 
1820 /*--------------------------------------------------------------------------*\
1821  * plgcol0Cmd
1822  *
1823  * Processes plgcol0 Tcl command.
1824 \*--------------------------------------------------------------------------*/
1825 
1826 static int
1827 plgcol0Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1828 {
1829  PLINT icol0;
1830  PLINT r;
1831  PLINT g;
1832  PLINT b;
1833 
1834  pl_errcode = 0; errmsg[0] = '\0';
1835 
1836  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1837  Tcl_AppendResult( interp, "command syntax: \"",
1838  "plgcol0 ?icol0 r g b?", "\"",
1839  (char *) NULL);
1840  return TCL_ERROR;
1841  }
1842 
1843  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
1844  (!1 && !0 && (argc != (4 + 1))) ||
1845  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
1846  Tcl_AppendResult( interp, "wrong # args: should be \"",
1847  "plgcol0 ?icol0 r g b?", "\"",
1848  (char *) NULL);
1849  return TCL_ERROR;
1850  }
1851 
1852  icol0 = atoi(argv[1+0]);
1853 /* r is for output. */
1854 /* g is for output. */
1855 /* b is for output. */
1856 
1857  plgcol0 ( icol0, &r, &g, &b );
1858 
1859  if (argc == 1)
1860  Tcl_AppendResult( interp, " ", (char *) NULL );
1861  sprintf( buf, "%d", r );
1862  if (argc > 1)
1863  Tcl_SetVar( interp, argv[1+1], buf, 0 );
1864  else
1865  Tcl_AppendResult( interp, buf, (char *) NULL );
1866  if (argc == 1)
1867  Tcl_AppendResult( interp, " ", (char *) NULL );
1868  sprintf( buf, "%d", g );
1869  if (argc > 1)
1870  Tcl_SetVar( interp, argv[1+2], buf, 0 );
1871  else
1872  Tcl_AppendResult( interp, buf, (char *) NULL );
1873  if (argc == 1)
1874  Tcl_AppendResult( interp, " ", (char *) NULL );
1875  sprintf( buf, "%d", b );
1876  if (argc > 1)
1877  Tcl_SetVar( interp, argv[1+3], buf, 0 );
1878  else
1879  Tcl_AppendResult( interp, buf, (char *) NULL );
1880 
1881  if (pl_errcode != 0) {
1882  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1883  return TCL_ERROR;
1884  }
1885 
1886  plflush();
1887  return TCL_OK;
1888 }
1889 
1890 /*--------------------------------------------------------------------------*\
1891  * plgcol0aCmd
1892  *
1893  * Processes plgcol0a Tcl command.
1894 \*--------------------------------------------------------------------------*/
1895 
1896 static int
1897 plgcol0aCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1898 {
1899  PLINT icol0;
1900  PLINT r;
1901  PLINT g;
1902  PLINT b;
1903  PLFLT a;
1904 
1905  pl_errcode = 0; errmsg[0] = '\0';
1906 
1907  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1908  Tcl_AppendResult( interp, "command syntax: \"",
1909  "plgcol0a ?icol0 r g b a?", "\"",
1910  (char *) NULL);
1911  return TCL_ERROR;
1912  }
1913 
1914  if ( (!1 && 0 && (argc < (1 + 5 - 0))) ||
1915  (!1 && !0 && (argc != (5 + 1))) ||
1916  ( 1 && (argc != 1) && (argc != (5 + 1))) ) {
1917  Tcl_AppendResult( interp, "wrong # args: should be \"",
1918  "plgcol0a ?icol0 r g b a?", "\"",
1919  (char *) NULL);
1920  return TCL_ERROR;
1921  }
1922 
1923  icol0 = atoi(argv[1+0]);
1924 /* r is for output. */
1925 /* g is for output. */
1926 /* b is for output. */
1927 /* a is for output. */
1928 
1929  plgcol0a ( icol0, &r, &g, &b, &a );
1930 
1931  if (argc == 1)
1932  Tcl_AppendResult( interp, " ", (char *) NULL );
1933  sprintf( buf, "%d", r );
1934  if (argc > 1)
1935  Tcl_SetVar( interp, argv[1+1], buf, 0 );
1936  else
1937  Tcl_AppendResult( interp, buf, (char *) NULL );
1938  if (argc == 1)
1939  Tcl_AppendResult( interp, " ", (char *) NULL );
1940  sprintf( buf, "%d", g );
1941  if (argc > 1)
1942  Tcl_SetVar( interp, argv[1+2], buf, 0 );
1943  else
1944  Tcl_AppendResult( interp, buf, (char *) NULL );
1945  if (argc == 1)
1946  Tcl_AppendResult( interp, " ", (char *) NULL );
1947  sprintf( buf, "%d", b );
1948  if (argc > 1)
1949  Tcl_SetVar( interp, argv[1+3], buf, 0 );
1950  else
1951  Tcl_AppendResult( interp, buf, (char *) NULL );
1952  if (argc == 1)
1953  Tcl_AppendResult( interp, " ", (char *) NULL );
1954  Tcl_PrintDouble( interp, a, buf );
1955  if (argc > 1)
1956  Tcl_SetVar( interp, argv[1+4], buf, 0 );
1957  else
1958  Tcl_AppendResult( interp, buf, (char *) NULL );
1959 
1960  if (pl_errcode != 0) {
1961  Tcl_AppendResult(interp, errmsg, (char *) NULL);
1962  return TCL_ERROR;
1963  }
1964 
1965  plflush();
1966  return TCL_OK;
1967 }
1968 
1969 /*--------------------------------------------------------------------------*\
1970  * plgcolbgCmd
1971  *
1972  * Processes plgcolbg Tcl command.
1973 \*--------------------------------------------------------------------------*/
1974 
1975 static int
1976 plgcolbgCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
1977 {
1978  PLINT r;
1979  PLINT g;
1980  PLINT b;
1981 
1982  pl_errcode = 0; errmsg[0] = '\0';
1983 
1984  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
1985  Tcl_AppendResult( interp, "command syntax: \"",
1986  "plgcolbg ?r g b?", "\"",
1987  (char *) NULL);
1988  return TCL_ERROR;
1989  }
1990 
1991  if ( (!1 && 0 && (argc < (1 + 3 - 0))) ||
1992  (!1 && !0 && (argc != (3 + 1))) ||
1993  ( 1 && (argc != 1) && (argc != (3 + 1))) ) {
1994  Tcl_AppendResult( interp, "wrong # args: should be \"",
1995  "plgcolbg ?r g b?", "\"",
1996  (char *) NULL);
1997  return TCL_ERROR;
1998  }
1999 
2000 /* r is for output. */
2001 /* g is for output. */
2002 /* b is for output. */
2003 
2004  plgcolbg ( &r, &g, &b );
2005 
2006  sprintf( buf, "%d", r );
2007  if (argc > 1)
2008  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2009  else
2010  Tcl_AppendResult( interp, buf, (char *) NULL );
2011  if (argc == 1)
2012  Tcl_AppendResult( interp, " ", (char *) NULL );
2013  sprintf( buf, "%d", g );
2014  if (argc > 1)
2015  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2016  else
2017  Tcl_AppendResult( interp, buf, (char *) NULL );
2018  if (argc == 1)
2019  Tcl_AppendResult( interp, " ", (char *) NULL );
2020  sprintf( buf, "%d", b );
2021  if (argc > 1)
2022  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2023  else
2024  Tcl_AppendResult( interp, buf, (char *) NULL );
2025 
2026  if (pl_errcode != 0) {
2027  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2028  return TCL_ERROR;
2029  }
2030 
2031  plflush();
2032  return TCL_OK;
2033 }
2034 
2035 /*--------------------------------------------------------------------------*\
2036  * plgcolbgaCmd
2037  *
2038  * Processes plgcolbga Tcl command.
2039 \*--------------------------------------------------------------------------*/
2040 
2041 static int
2042 plgcolbgaCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2043 {
2044  PLINT r;
2045  PLINT g;
2046  PLINT b;
2047  PLFLT a;
2048 
2049  pl_errcode = 0; errmsg[0] = '\0';
2050 
2051  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2052  Tcl_AppendResult( interp, "command syntax: \"",
2053  "plgcolbga ?r g b a?", "\"",
2054  (char *) NULL);
2055  return TCL_ERROR;
2056  }
2057 
2058  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
2059  (!1 && !0 && (argc != (4 + 1))) ||
2060  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
2061  Tcl_AppendResult( interp, "wrong # args: should be \"",
2062  "plgcolbga ?r g b a?", "\"",
2063  (char *) NULL);
2064  return TCL_ERROR;
2065  }
2066 
2067 /* r is for output. */
2068 /* g is for output. */
2069 /* b is for output. */
2070 /* a is for output. */
2071 
2072  plgcolbga ( &r, &g, &b, &a );
2073 
2074  sprintf( buf, "%d", r );
2075  if (argc > 1)
2076  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2077  else
2078  Tcl_AppendResult( interp, buf, (char *) NULL );
2079  if (argc == 1)
2080  Tcl_AppendResult( interp, " ", (char *) NULL );
2081  sprintf( buf, "%d", g );
2082  if (argc > 1)
2083  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2084  else
2085  Tcl_AppendResult( interp, buf, (char *) NULL );
2086  if (argc == 1)
2087  Tcl_AppendResult( interp, " ", (char *) NULL );
2088  sprintf( buf, "%d", b );
2089  if (argc > 1)
2090  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2091  else
2092  Tcl_AppendResult( interp, buf, (char *) NULL );
2093  if (argc == 1)
2094  Tcl_AppendResult( interp, " ", (char *) NULL );
2095  Tcl_PrintDouble( interp, a, buf );
2096  if (argc > 1)
2097  Tcl_SetVar( interp, argv[1+3], buf, 0 );
2098  else
2099  Tcl_AppendResult( interp, buf, (char *) NULL );
2100 
2101  if (pl_errcode != 0) {
2102  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2103  return TCL_ERROR;
2104  }
2105 
2106  plflush();
2107  return TCL_OK;
2108 }
2109 
2110 /*--------------------------------------------------------------------------*\
2111  * plgcompressionCmd
2112  *
2113  * Processes plgcompression Tcl command.
2114 \*--------------------------------------------------------------------------*/
2115 
2116 static int
2117 plgcompressionCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2118 {
2119  PLINT compression;
2120 
2121  pl_errcode = 0; errmsg[0] = '\0';
2122 
2123  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2124  Tcl_AppendResult( interp, "command syntax: \"",
2125  "plgcompression ?compression?", "\"",
2126  (char *) NULL);
2127  return TCL_ERROR;
2128  }
2129 
2130  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2131  (!1 && !0 && (argc != (1 + 1))) ||
2132  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2133  Tcl_AppendResult( interp, "wrong # args: should be \"",
2134  "plgcompression ?compression?", "\"",
2135  (char *) NULL);
2136  return TCL_ERROR;
2137  }
2138 
2139 /* compression is for output. */
2140 
2141  plgcompression ( &compression );
2142 
2143  sprintf( buf, "%d", compression );
2144  if (argc > 1)
2145  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2146  else
2147  Tcl_AppendResult( interp, buf, (char *) NULL );
2148 
2149  if (pl_errcode != 0) {
2150  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2151  return TCL_ERROR;
2152  }
2153 
2154  plflush();
2155  return TCL_OK;
2156 }
2157 
2158 /*--------------------------------------------------------------------------*\
2159  * plgdevCmd
2160  *
2161  * Processes plgdev Tcl command.
2162 \*--------------------------------------------------------------------------*/
2163 
2164 static int
2165 plgdevCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2166 {
2167  char devnam[200];
2168 
2169  pl_errcode = 0; errmsg[0] = '\0';
2170 
2171  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2172  Tcl_AppendResult( interp, "command syntax: \"",
2173  "plgdev ?devnam?", "\"",
2174  (char *) NULL);
2175  return TCL_ERROR;
2176  }
2177 
2178  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2179  (!1 && !0 && (argc != (1 + 1))) ||
2180  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2181  Tcl_AppendResult( interp, "wrong # args: should be \"",
2182  "plgdev ?devnam?", "\"",
2183  (char *) NULL);
2184  return TCL_ERROR;
2185  }
2186 
2187 /* devnam is for output. */
2188 
2189  plgdev ( devnam );
2190 
2191  if (argc > 1)
2192  Tcl_SetVar( interp, argv[1+0], devnam, 0 );
2193  else
2194  Tcl_AppendResult( interp, devnam, (char *) NULL );
2195 
2196  if (pl_errcode != 0) {
2197  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2198  return TCL_ERROR;
2199  }
2200 
2201  plflush();
2202  return TCL_OK;
2203 }
2204 
2205 /*--------------------------------------------------------------------------*\
2206  * plgdidevCmd
2207  *
2208  * Processes plgdidev Tcl command.
2209 \*--------------------------------------------------------------------------*/
2210 
2211 static int
2212 plgdidevCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2213 {
2214  PLFLT mar;
2215  PLFLT aspect;
2216  PLFLT jx;
2217  PLFLT jy;
2218 
2219  pl_errcode = 0; errmsg[0] = '\0';
2220 
2221  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2222  Tcl_AppendResult( interp, "command syntax: \"",
2223  "plgdidev ?mar aspect jx jy?", "\"",
2224  (char *) NULL);
2225  return TCL_ERROR;
2226  }
2227 
2228  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
2229  (!1 && !0 && (argc != (4 + 1))) ||
2230  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
2231  Tcl_AppendResult( interp, "wrong # args: should be \"",
2232  "plgdidev ?mar aspect jx jy?", "\"",
2233  (char *) NULL);
2234  return TCL_ERROR;
2235  }
2236 
2237 /* mar is for output. */
2238 /* aspect is for output. */
2239 /* jx is for output. */
2240 /* jy is for output. */
2241 
2242  plgdidev ( &mar, &aspect, &jx, &jy );
2243 
2244  Tcl_PrintDouble( interp, mar, buf );
2245  if (argc > 1)
2246  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2247  else
2248  Tcl_AppendResult( interp, buf, (char *) NULL );
2249  if (argc == 1)
2250  Tcl_AppendResult( interp, " ", (char *) NULL );
2251  Tcl_PrintDouble( interp, aspect, buf );
2252  if (argc > 1)
2253  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2254  else
2255  Tcl_AppendResult( interp, buf, (char *) NULL );
2256  if (argc == 1)
2257  Tcl_AppendResult( interp, " ", (char *) NULL );
2258  Tcl_PrintDouble( interp, jx, buf );
2259  if (argc > 1)
2260  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2261  else
2262  Tcl_AppendResult( interp, buf, (char *) NULL );
2263  if (argc == 1)
2264  Tcl_AppendResult( interp, " ", (char *) NULL );
2265  Tcl_PrintDouble( interp, jy, buf );
2266  if (argc > 1)
2267  Tcl_SetVar( interp, argv[1+3], buf, 0 );
2268  else
2269  Tcl_AppendResult( interp, buf, (char *) NULL );
2270 
2271  if (pl_errcode != 0) {
2272  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2273  return TCL_ERROR;
2274  }
2275 
2276  plflush();
2277  return TCL_OK;
2278 }
2279 
2280 /*--------------------------------------------------------------------------*\
2281  * plgdioriCmd
2282  *
2283  * Processes plgdiori Tcl command.
2284 \*--------------------------------------------------------------------------*/
2285 
2286 static int
2287 plgdioriCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2288 {
2289  PLFLT rot;
2290 
2291  pl_errcode = 0; errmsg[0] = '\0';
2292 
2293  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2294  Tcl_AppendResult( interp, "command syntax: \"",
2295  "plgdiori ?rot?", "\"",
2296  (char *) NULL);
2297  return TCL_ERROR;
2298  }
2299 
2300  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2301  (!1 && !0 && (argc != (1 + 1))) ||
2302  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2303  Tcl_AppendResult( interp, "wrong # args: should be \"",
2304  "plgdiori ?rot?", "\"",
2305  (char *) NULL);
2306  return TCL_ERROR;
2307  }
2308 
2309 /* rot is for output. */
2310 
2311  plgdiori ( &rot );
2312 
2313  Tcl_PrintDouble( interp, rot, buf );
2314  if (argc > 1)
2315  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2316  else
2317  Tcl_AppendResult( interp, buf, (char *) NULL );
2318 
2319  if (pl_errcode != 0) {
2320  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2321  return TCL_ERROR;
2322  }
2323 
2324  plflush();
2325  return TCL_OK;
2326 }
2327 
2328 /*--------------------------------------------------------------------------*\
2329  * plgdipltCmd
2330  *
2331  * Processes plgdiplt Tcl command.
2332 \*--------------------------------------------------------------------------*/
2333 
2334 static int
2335 plgdipltCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2336 {
2337  PLFLT xmin;
2338  PLFLT ymin;
2339  PLFLT xmax;
2340  PLFLT ymax;
2341 
2342  pl_errcode = 0; errmsg[0] = '\0';
2343 
2344  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2345  Tcl_AppendResult( interp, "command syntax: \"",
2346  "plgdiplt ?xmin ymin xmax ymax?", "\"",
2347  (char *) NULL);
2348  return TCL_ERROR;
2349  }
2350 
2351  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
2352  (!1 && !0 && (argc != (4 + 1))) ||
2353  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
2354  Tcl_AppendResult( interp, "wrong # args: should be \"",
2355  "plgdiplt ?xmin ymin xmax ymax?", "\"",
2356  (char *) NULL);
2357  return TCL_ERROR;
2358  }
2359 
2360 /* xmin is for output. */
2361 /* ymin is for output. */
2362 /* xmax is for output. */
2363 /* ymax is for output. */
2364 
2365  plgdiplt ( &xmin, &ymin, &xmax, &ymax );
2366 
2367  Tcl_PrintDouble( interp, xmin, buf );
2368  if (argc > 1)
2369  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2370  else
2371  Tcl_AppendResult( interp, buf, (char *) NULL );
2372  if (argc == 1)
2373  Tcl_AppendResult( interp, " ", (char *) NULL );
2374  Tcl_PrintDouble( interp, ymin, buf );
2375  if (argc > 1)
2376  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2377  else
2378  Tcl_AppendResult( interp, buf, (char *) NULL );
2379  if (argc == 1)
2380  Tcl_AppendResult( interp, " ", (char *) NULL );
2381  Tcl_PrintDouble( interp, xmax, buf );
2382  if (argc > 1)
2383  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2384  else
2385  Tcl_AppendResult( interp, buf, (char *) NULL );
2386  if (argc == 1)
2387  Tcl_AppendResult( interp, " ", (char *) NULL );
2388  Tcl_PrintDouble( interp, ymax, buf );
2389  if (argc > 1)
2390  Tcl_SetVar( interp, argv[1+3], buf, 0 );
2391  else
2392  Tcl_AppendResult( interp, buf, (char *) NULL );
2393 
2394  if (pl_errcode != 0) {
2395  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2396  return TCL_ERROR;
2397  }
2398 
2399  plflush();
2400  return TCL_OK;
2401 }
2402 
2403 /*--------------------------------------------------------------------------*\
2404  * plgescCmd
2405  *
2406  * Processes plgesc Tcl command.
2407 \*--------------------------------------------------------------------------*/
2408 
2409 static int
2410 plgescCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2411 {
2412  char esc;
2413 
2414  pl_errcode = 0; errmsg[0] = '\0';
2415 
2416  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2417  Tcl_AppendResult( interp, "command syntax: \"",
2418  "plgesc ?esc?", "\"",
2419  (char *) NULL);
2420  return TCL_ERROR;
2421  }
2422 
2423  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2424  (!1 && !0 && (argc != (1 + 1))) ||
2425  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2426  Tcl_AppendResult( interp, "wrong # args: should be \"",
2427  "plgesc ?esc?", "\"",
2428  (char *) NULL);
2429  return TCL_ERROR;
2430  }
2431 
2432 /* esc is for output. */
2433 
2434  plgesc ( &esc );
2435 
2436  sprintf( buf, "%c", esc );
2437  if (argc > 1)
2438  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2439  else
2440  Tcl_AppendResult( interp, buf, (char *) NULL );
2441 
2442  if (pl_errcode != 0) {
2443  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2444  return TCL_ERROR;
2445  }
2446 
2447  plflush();
2448  return TCL_OK;
2449 }
2450 
2451 /*--------------------------------------------------------------------------*\
2452  * plgfamCmd
2453  *
2454  * Processes plgfam Tcl command.
2455 \*--------------------------------------------------------------------------*/
2456 
2457 static int
2458 plgfamCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2459 {
2460  PLINT fam;
2461  PLINT num;
2462  PLINT bmax;
2463 
2464  pl_errcode = 0; errmsg[0] = '\0';
2465 
2466  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2467  Tcl_AppendResult( interp, "command syntax: \"",
2468  "plgfam ?fam num bmax?", "\"",
2469  (char *) NULL);
2470  return TCL_ERROR;
2471  }
2472 
2473  if ( (!1 && 0 && (argc < (1 + 3 - 0))) ||
2474  (!1 && !0 && (argc != (3 + 1))) ||
2475  ( 1 && (argc != 1) && (argc != (3 + 1))) ) {
2476  Tcl_AppendResult( interp, "wrong # args: should be \"",
2477  "plgfam ?fam num bmax?", "\"",
2478  (char *) NULL);
2479  return TCL_ERROR;
2480  }
2481 
2482 /* fam is for output. */
2483 /* num is for output. */
2484 /* bmax is for output. */
2485 
2486  plgfam ( &fam, &num, &bmax );
2487 
2488  sprintf( buf, "%d", fam );
2489  if (argc > 1)
2490  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2491  else
2492  Tcl_AppendResult( interp, buf, (char *) NULL );
2493  if (argc == 1)
2494  Tcl_AppendResult( interp, " ", (char *) NULL );
2495  sprintf( buf, "%d", num );
2496  if (argc > 1)
2497  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2498  else
2499  Tcl_AppendResult( interp, buf, (char *) NULL );
2500  if (argc == 1)
2501  Tcl_AppendResult( interp, " ", (char *) NULL );
2502  sprintf( buf, "%d", bmax );
2503  if (argc > 1)
2504  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2505  else
2506  Tcl_AppendResult( interp, buf, (char *) NULL );
2507 
2508  if (pl_errcode != 0) {
2509  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2510  return TCL_ERROR;
2511  }
2512 
2513  plflush();
2514  return TCL_OK;
2515 }
2516 
2517 /*--------------------------------------------------------------------------*\
2518  * plgfciCmd
2519  *
2520  * Processes plgfci Tcl command.
2521 \*--------------------------------------------------------------------------*/
2522 
2523 static int
2524 plgfciCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2525 {
2526  PLUNICODE fci;
2527 
2528  pl_errcode = 0; errmsg[0] = '\0';
2529 
2530  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2531  Tcl_AppendResult( interp, "command syntax: \"",
2532  "plgfci ?fci?", "\"",
2533  (char *) NULL);
2534  return TCL_ERROR;
2535  }
2536 
2537  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2538  (!1 && !0 && (argc != (1 + 1))) ||
2539  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2540  Tcl_AppendResult( interp, "wrong # args: should be \"",
2541  "plgfci ?fci?", "\"",
2542  (char *) NULL);
2543  return TCL_ERROR;
2544  }
2545 
2546 /* fci is for output. */
2547 
2548  plgfci ( &fci );
2549 
2550  sprintf( buf, "%u", fci );
2551  if (argc > 1)
2552  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2553  else
2554  Tcl_AppendResult( interp, buf, (char *) NULL );
2555 
2556  if (pl_errcode != 0) {
2557  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2558  return TCL_ERROR;
2559  }
2560 
2561  plflush();
2562  return TCL_OK;
2563 }
2564 
2565 /*--------------------------------------------------------------------------*\
2566  * plgfnamCmd
2567  *
2568  * Processes plgfnam Tcl command.
2569 \*--------------------------------------------------------------------------*/
2570 
2571 static int
2572 plgfnamCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2573 {
2574  char fnam[200];
2575 
2576  pl_errcode = 0; errmsg[0] = '\0';
2577 
2578  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2579  Tcl_AppendResult( interp, "command syntax: \"",
2580  "plgfnam ?fnam?", "\"",
2581  (char *) NULL);
2582  return TCL_ERROR;
2583  }
2584 
2585  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2586  (!1 && !0 && (argc != (1 + 1))) ||
2587  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2588  Tcl_AppendResult( interp, "wrong # args: should be \"",
2589  "plgfnam ?fnam?", "\"",
2590  (char *) NULL);
2591  return TCL_ERROR;
2592  }
2593 
2594 /* fnam is for output. */
2595 
2596  plgfnam ( fnam );
2597 
2598  if (argc > 1)
2599  Tcl_SetVar( interp, argv[1+0], fnam, 0 );
2600  else
2601  Tcl_AppendResult( interp, fnam, (char *) NULL );
2602 
2603  if (pl_errcode != 0) {
2604  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2605  return TCL_ERROR;
2606  }
2607 
2608  plflush();
2609  return TCL_OK;
2610 }
2611 
2612 /*--------------------------------------------------------------------------*\
2613  * plgfontCmd
2614  *
2615  * Processes plgfont Tcl command.
2616 \*--------------------------------------------------------------------------*/
2617 
2618 static int
2619 plgfontCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2620 {
2621  PLINT family;
2622  PLINT style;
2623  PLINT weight;
2624 
2625  pl_errcode = 0; errmsg[0] = '\0';
2626 
2627  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2628  Tcl_AppendResult( interp, "command syntax: \"",
2629  "plgfont ?family style weight?", "\"",
2630  (char *) NULL);
2631  return TCL_ERROR;
2632  }
2633 
2634  if ( (!1 && 0 && (argc < (1 + 3 - 0))) ||
2635  (!1 && !0 && (argc != (3 + 1))) ||
2636  ( 1 && (argc != 1) && (argc != (3 + 1))) ) {
2637  Tcl_AppendResult( interp, "wrong # args: should be \"",
2638  "plgfont ?family style weight?", "\"",
2639  (char *) NULL);
2640  return TCL_ERROR;
2641  }
2642 
2643 /* family is for output. */
2644 /* style is for output. */
2645 /* weight is for output. */
2646 
2647  plgfont ( &family, &style, &weight );
2648 
2649  sprintf( buf, "%d", family );
2650  if (argc > 1)
2651  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2652  else
2653  Tcl_AppendResult( interp, buf, (char *) NULL );
2654  if (argc == 1)
2655  Tcl_AppendResult( interp, " ", (char *) NULL );
2656  sprintf( buf, "%d", style );
2657  if (argc > 1)
2658  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2659  else
2660  Tcl_AppendResult( interp, buf, (char *) NULL );
2661  if (argc == 1)
2662  Tcl_AppendResult( interp, " ", (char *) NULL );
2663  sprintf( buf, "%d", weight );
2664  if (argc > 1)
2665  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2666  else
2667  Tcl_AppendResult( interp, buf, (char *) NULL );
2668 
2669  if (pl_errcode != 0) {
2670  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2671  return TCL_ERROR;
2672  }
2673 
2674  plflush();
2675  return TCL_OK;
2676 }
2677 
2678 /*--------------------------------------------------------------------------*\
2679  * plglevelCmd
2680  *
2681  * Processes plglevel Tcl command.
2682 \*--------------------------------------------------------------------------*/
2683 
2684 static int
2685 plglevelCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2686 {
2687  PLINT level;
2688 
2689  pl_errcode = 0; errmsg[0] = '\0';
2690 
2691  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2692  Tcl_AppendResult( interp, "command syntax: \"",
2693  "plglevel ?level?", "\"",
2694  (char *) NULL);
2695  return TCL_ERROR;
2696  }
2697 
2698  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
2699  (!1 && !0 && (argc != (1 + 1))) ||
2700  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
2701  Tcl_AppendResult( interp, "wrong # args: should be \"",
2702  "plglevel ?level?", "\"",
2703  (char *) NULL);
2704  return TCL_ERROR;
2705  }
2706 
2707 /* level is for output. */
2708 
2709  plglevel ( &level );
2710 
2711  sprintf( buf, "%d", level );
2712  if (argc > 1)
2713  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2714  else
2715  Tcl_AppendResult( interp, buf, (char *) NULL );
2716 
2717  if (pl_errcode != 0) {
2718  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2719  return TCL_ERROR;
2720  }
2721 
2722  plflush();
2723  return TCL_OK;
2724 }
2725 
2726 /*--------------------------------------------------------------------------*\
2727  * plgpageCmd
2728  *
2729  * Processes plgpage Tcl command.
2730 \*--------------------------------------------------------------------------*/
2731 
2732 static int
2733 plgpageCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2734 {
2735  PLFLT xp;
2736  PLFLT yp;
2737  PLINT xleng;
2738  PLINT yleng;
2739  PLINT xoff;
2740  PLINT yoff;
2741 
2742  pl_errcode = 0; errmsg[0] = '\0';
2743 
2744  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2745  Tcl_AppendResult( interp, "command syntax: \"",
2746  "plgpage ?xp yp xleng yleng xoff yoff?", "\"",
2747  (char *) NULL);
2748  return TCL_ERROR;
2749  }
2750 
2751  if ( (!1 && 0 && (argc < (1 + 6 - 0))) ||
2752  (!1 && !0 && (argc != (6 + 1))) ||
2753  ( 1 && (argc != 1) && (argc != (6 + 1))) ) {
2754  Tcl_AppendResult( interp, "wrong # args: should be \"",
2755  "plgpage ?xp yp xleng yleng xoff yoff?", "\"",
2756  (char *) NULL);
2757  return TCL_ERROR;
2758  }
2759 
2760 /* xp is for output. */
2761 /* yp is for output. */
2762 /* xleng is for output. */
2763 /* yleng is for output. */
2764 /* xoff is for output. */
2765 /* yoff is for output. */
2766 
2767  plgpage ( &xp, &yp, &xleng, &yleng, &xoff, &yoff );
2768 
2769  Tcl_PrintDouble( interp, xp, buf );
2770  if (argc > 1)
2771  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2772  else
2773  Tcl_AppendResult( interp, buf, (char *) NULL );
2774  if (argc == 1)
2775  Tcl_AppendResult( interp, " ", (char *) NULL );
2776  Tcl_PrintDouble( interp, yp, buf );
2777  if (argc > 1)
2778  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2779  else
2780  Tcl_AppendResult( interp, buf, (char *) NULL );
2781  if (argc == 1)
2782  Tcl_AppendResult( interp, " ", (char *) NULL );
2783  sprintf( buf, "%d", xleng );
2784  if (argc > 1)
2785  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2786  else
2787  Tcl_AppendResult( interp, buf, (char *) NULL );
2788  if (argc == 1)
2789  Tcl_AppendResult( interp, " ", (char *) NULL );
2790  sprintf( buf, "%d", yleng );
2791  if (argc > 1)
2792  Tcl_SetVar( interp, argv[1+3], buf, 0 );
2793  else
2794  Tcl_AppendResult( interp, buf, (char *) NULL );
2795  if (argc == 1)
2796  Tcl_AppendResult( interp, " ", (char *) NULL );
2797  sprintf( buf, "%d", xoff );
2798  if (argc > 1)
2799  Tcl_SetVar( interp, argv[1+4], buf, 0 );
2800  else
2801  Tcl_AppendResult( interp, buf, (char *) NULL );
2802  if (argc == 1)
2803  Tcl_AppendResult( interp, " ", (char *) NULL );
2804  sprintf( buf, "%d", yoff );
2805  if (argc > 1)
2806  Tcl_SetVar( interp, argv[1+5], buf, 0 );
2807  else
2808  Tcl_AppendResult( interp, buf, (char *) NULL );
2809 
2810  if (pl_errcode != 0) {
2811  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2812  return TCL_ERROR;
2813  }
2814 
2815  plflush();
2816  return TCL_OK;
2817 }
2818 
2819 /*--------------------------------------------------------------------------*\
2820  * plgraCmd
2821  *
2822  * Processes plgra Tcl command.
2823 \*--------------------------------------------------------------------------*/
2824 
2825 static int
2826 plgraCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2827 {
2828 
2829  pl_errcode = 0; errmsg[0] = '\0';
2830 
2831  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2832  Tcl_AppendResult( interp, "command syntax: \"",
2833  "plgra ", "\"",
2834  (char *) NULL);
2835  return TCL_ERROR;
2836  }
2837 
2838  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
2839  (!0 && !0 && (argc != (0 + 1))) ||
2840  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
2841  Tcl_AppendResult( interp, "wrong # args: should be \"",
2842  "plgra ", "\"",
2843  (char *) NULL);
2844  return TCL_ERROR;
2845  }
2846 
2847 
2848  plgra ( );
2849 
2850 
2851  if (pl_errcode != 0) {
2852  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2853  return TCL_ERROR;
2854  }
2855 
2856  plflush();
2857  return TCL_OK;
2858 }
2859 
2860 /*--------------------------------------------------------------------------*\
2861  * plgradientCmd
2862  *
2863  * Processes plgradient Tcl command.
2864 \*--------------------------------------------------------------------------*/
2865 
2866 static int
2867 plgradientCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2868 {
2869  PLINT n;
2870  PLFLT *x;
2871  tclMatrix *matx;
2872  PLFLT *y;
2873  tclMatrix *maty;
2874  PLFLT angle;
2875 
2876  pl_errcode = 0; errmsg[0] = '\0';
2877 
2878  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2879  Tcl_AppendResult( interp, "command syntax: \"",
2880  "plgradient n x y angle", "\"",
2881  (char *) NULL);
2882  return TCL_ERROR;
2883  }
2884 
2885  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
2886  (!0 && !0 && (argc != (4 + 1))) ||
2887  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
2888  Tcl_AppendResult( interp, "wrong # args: should be \"",
2889  "plgradient n x y angle", "\"",
2890  (char *) NULL);
2891  return TCL_ERROR;
2892  }
2893 
2894  n = atoi(argv[1+0]);
2895  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
2896  if (matx == NULL) return TCL_ERROR;
2897  x = matx->fdata;
2898  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
2899  if (maty == NULL) return TCL_ERROR;
2900  y = maty->fdata;
2901  angle = atof(argv[1+3]);
2902 
2903  plgradient ( n, x, y, angle );
2904 
2905 
2906  if (pl_errcode != 0) {
2907  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2908  return TCL_ERROR;
2909  }
2910 
2911  plflush();
2912  return TCL_OK;
2913 }
2914 
2915 /*--------------------------------------------------------------------------*\
2916  * plgspaCmd
2917  *
2918  * Processes plgspa Tcl command.
2919 \*--------------------------------------------------------------------------*/
2920 
2921 static int
2922 plgspaCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2923 {
2924  PLFLT xmin;
2925  PLFLT xmax;
2926  PLFLT ymin;
2927  PLFLT ymax;
2928 
2929  pl_errcode = 0; errmsg[0] = '\0';
2930 
2931  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
2932  Tcl_AppendResult( interp, "command syntax: \"",
2933  "plgspa ?xmin xmax ymin ymax?", "\"",
2934  (char *) NULL);
2935  return TCL_ERROR;
2936  }
2937 
2938  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
2939  (!1 && !0 && (argc != (4 + 1))) ||
2940  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
2941  Tcl_AppendResult( interp, "wrong # args: should be \"",
2942  "plgspa ?xmin xmax ymin ymax?", "\"",
2943  (char *) NULL);
2944  return TCL_ERROR;
2945  }
2946 
2947 /* xmin is for output. */
2948 /* xmax is for output. */
2949 /* ymin is for output. */
2950 /* ymax is for output. */
2951 
2952  plgspa ( &xmin, &xmax, &ymin, &ymax );
2953 
2954  Tcl_PrintDouble( interp, xmin, buf );
2955  if (argc > 1)
2956  Tcl_SetVar( interp, argv[1+0], buf, 0 );
2957  else
2958  Tcl_AppendResult( interp, buf, (char *) NULL );
2959  if (argc == 1)
2960  Tcl_AppendResult( interp, " ", (char *) NULL );
2961  Tcl_PrintDouble( interp, xmax, buf );
2962  if (argc > 1)
2963  Tcl_SetVar( interp, argv[1+1], buf, 0 );
2964  else
2965  Tcl_AppendResult( interp, buf, (char *) NULL );
2966  if (argc == 1)
2967  Tcl_AppendResult( interp, " ", (char *) NULL );
2968  Tcl_PrintDouble( interp, ymin, buf );
2969  if (argc > 1)
2970  Tcl_SetVar( interp, argv[1+2], buf, 0 );
2971  else
2972  Tcl_AppendResult( interp, buf, (char *) NULL );
2973  if (argc == 1)
2974  Tcl_AppendResult( interp, " ", (char *) NULL );
2975  Tcl_PrintDouble( interp, ymax, buf );
2976  if (argc > 1)
2977  Tcl_SetVar( interp, argv[1+3], buf, 0 );
2978  else
2979  Tcl_AppendResult( interp, buf, (char *) NULL );
2980 
2981  if (pl_errcode != 0) {
2982  Tcl_AppendResult(interp, errmsg, (char *) NULL);
2983  return TCL_ERROR;
2984  }
2985 
2986  plflush();
2987  return TCL_OK;
2988 }
2989 
2990 /*--------------------------------------------------------------------------*\
2991  * plgstrmCmd
2992  *
2993  * Processes plgstrm Tcl command.
2994 \*--------------------------------------------------------------------------*/
2995 
2996 static int
2997 plgstrmCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
2998 {
2999  PLINT strm;
3000 
3001  pl_errcode = 0; errmsg[0] = '\0';
3002 
3003  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3004  Tcl_AppendResult( interp, "command syntax: \"",
3005  "plgstrm ?strm?", "\"",
3006  (char *) NULL);
3007  return TCL_ERROR;
3008  }
3009 
3010  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
3011  (!1 && !0 && (argc != (1 + 1))) ||
3012  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
3013  Tcl_AppendResult( interp, "wrong # args: should be \"",
3014  "plgstrm ?strm?", "\"",
3015  (char *) NULL);
3016  return TCL_ERROR;
3017  }
3018 
3019 /* strm is for output. */
3020 
3021  plgstrm ( &strm );
3022 
3023  sprintf( buf, "%d", strm );
3024  if (argc > 1)
3025  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3026  else
3027  Tcl_AppendResult( interp, buf, (char *) NULL );
3028 
3029  if (pl_errcode != 0) {
3030  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3031  return TCL_ERROR;
3032  }
3033 
3034  plflush();
3035  return TCL_OK;
3036 }
3037 
3038 /*--------------------------------------------------------------------------*\
3039  * plgverCmd
3040  *
3041  * Processes plgver Tcl command.
3042 \*--------------------------------------------------------------------------*/
3043 
3044 static int
3045 plgverCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3046 {
3047  char ver[200];
3048 
3049  pl_errcode = 0; errmsg[0] = '\0';
3050 
3051  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3052  Tcl_AppendResult( interp, "command syntax: \"",
3053  "plgver ?ver?", "\"",
3054  (char *) NULL);
3055  return TCL_ERROR;
3056  }
3057 
3058  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
3059  (!1 && !0 && (argc != (1 + 1))) ||
3060  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
3061  Tcl_AppendResult( interp, "wrong # args: should be \"",
3062  "plgver ?ver?", "\"",
3063  (char *) NULL);
3064  return TCL_ERROR;
3065  }
3066 
3067 /* ver is for output. */
3068 
3069  plgver ( ver );
3070 
3071  if (argc > 1)
3072  Tcl_SetVar( interp, argv[1+0], ver, 0 );
3073  else
3074  Tcl_AppendResult( interp, ver, (char *) NULL );
3075 
3076  if (pl_errcode != 0) {
3077  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3078  return TCL_ERROR;
3079  }
3080 
3081  plflush();
3082  return TCL_OK;
3083 }
3084 
3085 /*--------------------------------------------------------------------------*\
3086  * plgvpdCmd
3087  *
3088  * Processes plgvpd Tcl command.
3089 \*--------------------------------------------------------------------------*/
3090 
3091 static int
3092 plgvpdCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3093 {
3094  PLFLT xmin;
3095  PLFLT xmax;
3096  PLFLT ymin;
3097  PLFLT ymax;
3098 
3099  pl_errcode = 0; errmsg[0] = '\0';
3100 
3101  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3102  Tcl_AppendResult( interp, "command syntax: \"",
3103  "plgvpd ?xmin xmax ymin ymax?", "\"",
3104  (char *) NULL);
3105  return TCL_ERROR;
3106  }
3107 
3108  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
3109  (!1 && !0 && (argc != (4 + 1))) ||
3110  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
3111  Tcl_AppendResult( interp, "wrong # args: should be \"",
3112  "plgvpd ?xmin xmax ymin ymax?", "\"",
3113  (char *) NULL);
3114  return TCL_ERROR;
3115  }
3116 
3117 /* xmin is for output. */
3118 /* xmax is for output. */
3119 /* ymin is for output. */
3120 /* ymax is for output. */
3121 
3122  plgvpd ( &xmin, &xmax, &ymin, &ymax );
3123 
3124  Tcl_PrintDouble( interp, xmin, buf );
3125  if (argc > 1)
3126  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3127  else
3128  Tcl_AppendResult( interp, buf, (char *) NULL );
3129  if (argc == 1)
3130  Tcl_AppendResult( interp, " ", (char *) NULL );
3131  Tcl_PrintDouble( interp, xmax, buf );
3132  if (argc > 1)
3133  Tcl_SetVar( interp, argv[1+1], buf, 0 );
3134  else
3135  Tcl_AppendResult( interp, buf, (char *) NULL );
3136  if (argc == 1)
3137  Tcl_AppendResult( interp, " ", (char *) NULL );
3138  Tcl_PrintDouble( interp, ymin, buf );
3139  if (argc > 1)
3140  Tcl_SetVar( interp, argv[1+2], buf, 0 );
3141  else
3142  Tcl_AppendResult( interp, buf, (char *) NULL );
3143  if (argc == 1)
3144  Tcl_AppendResult( interp, " ", (char *) NULL );
3145  Tcl_PrintDouble( interp, ymax, buf );
3146  if (argc > 1)
3147  Tcl_SetVar( interp, argv[1+3], buf, 0 );
3148  else
3149  Tcl_AppendResult( interp, buf, (char *) NULL );
3150 
3151  if (pl_errcode != 0) {
3152  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3153  return TCL_ERROR;
3154  }
3155 
3156  plflush();
3157  return TCL_OK;
3158 }
3159 
3160 /*--------------------------------------------------------------------------*\
3161  * plgvpwCmd
3162  *
3163  * Processes plgvpw Tcl command.
3164 \*--------------------------------------------------------------------------*/
3165 
3166 static int
3167 plgvpwCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3168 {
3169  PLFLT xmin;
3170  PLFLT xmax;
3171  PLFLT ymin;
3172  PLFLT ymax;
3173 
3174  pl_errcode = 0; errmsg[0] = '\0';
3175 
3176  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3177  Tcl_AppendResult( interp, "command syntax: \"",
3178  "plgvpw ?xmin xmax ymin ymax?", "\"",
3179  (char *) NULL);
3180  return TCL_ERROR;
3181  }
3182 
3183  if ( (!1 && 0 && (argc < (1 + 4 - 0))) ||
3184  (!1 && !0 && (argc != (4 + 1))) ||
3185  ( 1 && (argc != 1) && (argc != (4 + 1))) ) {
3186  Tcl_AppendResult( interp, "wrong # args: should be \"",
3187  "plgvpw ?xmin xmax ymin ymax?", "\"",
3188  (char *) NULL);
3189  return TCL_ERROR;
3190  }
3191 
3192 /* xmin is for output. */
3193 /* xmax is for output. */
3194 /* ymin is for output. */
3195 /* ymax is for output. */
3196 
3197  plgvpw ( &xmin, &xmax, &ymin, &ymax );
3198 
3199  Tcl_PrintDouble( interp, xmin, buf );
3200  if (argc > 1)
3201  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3202  else
3203  Tcl_AppendResult( interp, buf, (char *) NULL );
3204  if (argc == 1)
3205  Tcl_AppendResult( interp, " ", (char *) NULL );
3206  Tcl_PrintDouble( interp, xmax, buf );
3207  if (argc > 1)
3208  Tcl_SetVar( interp, argv[1+1], buf, 0 );
3209  else
3210  Tcl_AppendResult( interp, buf, (char *) NULL );
3211  if (argc == 1)
3212  Tcl_AppendResult( interp, " ", (char *) NULL );
3213  Tcl_PrintDouble( interp, ymin, buf );
3214  if (argc > 1)
3215  Tcl_SetVar( interp, argv[1+2], buf, 0 );
3216  else
3217  Tcl_AppendResult( interp, buf, (char *) NULL );
3218  if (argc == 1)
3219  Tcl_AppendResult( interp, " ", (char *) NULL );
3220  Tcl_PrintDouble( interp, ymax, buf );
3221  if (argc > 1)
3222  Tcl_SetVar( interp, argv[1+3], buf, 0 );
3223  else
3224  Tcl_AppendResult( interp, buf, (char *) NULL );
3225 
3226  if (pl_errcode != 0) {
3227  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3228  return TCL_ERROR;
3229  }
3230 
3231  plflush();
3232  return TCL_OK;
3233 }
3234 
3235 /*--------------------------------------------------------------------------*\
3236  * plgxaxCmd
3237  *
3238  * Processes plgxax Tcl command.
3239 \*--------------------------------------------------------------------------*/
3240 
3241 static int
3242 plgxaxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3243 {
3244  PLINT digmax;
3245  PLINT digits;
3246 
3247  pl_errcode = 0; errmsg[0] = '\0';
3248 
3249  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3250  Tcl_AppendResult( interp, "command syntax: \"",
3251  "plgxax ?digmax digits?", "\"",
3252  (char *) NULL);
3253  return TCL_ERROR;
3254  }
3255 
3256  if ( (!1 && 0 && (argc < (1 + 2 - 0))) ||
3257  (!1 && !0 && (argc != (2 + 1))) ||
3258  ( 1 && (argc != 1) && (argc != (2 + 1))) ) {
3259  Tcl_AppendResult( interp, "wrong # args: should be \"",
3260  "plgxax ?digmax digits?", "\"",
3261  (char *) NULL);
3262  return TCL_ERROR;
3263  }
3264 
3265 /* digmax is for output. */
3266 /* digits is for output. */
3267 
3268  plgxax ( &digmax, &digits );
3269 
3270  sprintf( buf, "%d", digmax );
3271  if (argc > 1)
3272  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3273  else
3274  Tcl_AppendResult( interp, buf, (char *) NULL );
3275  if (argc == 1)
3276  Tcl_AppendResult( interp, " ", (char *) NULL );
3277  sprintf( buf, "%d", digits );
3278  if (argc > 1)
3279  Tcl_SetVar( interp, argv[1+1], buf, 0 );
3280  else
3281  Tcl_AppendResult( interp, buf, (char *) NULL );
3282 
3283  if (pl_errcode != 0) {
3284  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3285  return TCL_ERROR;
3286  }
3287 
3288  plflush();
3289  return TCL_OK;
3290 }
3291 
3292 /*--------------------------------------------------------------------------*\
3293  * plgyaxCmd
3294  *
3295  * Processes plgyax Tcl command.
3296 \*--------------------------------------------------------------------------*/
3297 
3298 static int
3299 plgyaxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3300 {
3301  PLINT digmax;
3302  PLINT digits;
3303 
3304  pl_errcode = 0; errmsg[0] = '\0';
3305 
3306  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3307  Tcl_AppendResult( interp, "command syntax: \"",
3308  "plgyax ?digmax digits?", "\"",
3309  (char *) NULL);
3310  return TCL_ERROR;
3311  }
3312 
3313  if ( (!1 && 0 && (argc < (1 + 2 - 0))) ||
3314  (!1 && !0 && (argc != (2 + 1))) ||
3315  ( 1 && (argc != 1) && (argc != (2 + 1))) ) {
3316  Tcl_AppendResult( interp, "wrong # args: should be \"",
3317  "plgyax ?digmax digits?", "\"",
3318  (char *) NULL);
3319  return TCL_ERROR;
3320  }
3321 
3322 /* digmax is for output. */
3323 /* digits is for output. */
3324 
3325  plgyax ( &digmax, &digits );
3326 
3327  sprintf( buf, "%d", digmax );
3328  if (argc > 1)
3329  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3330  else
3331  Tcl_AppendResult( interp, buf, (char *) NULL );
3332  if (argc == 1)
3333  Tcl_AppendResult( interp, " ", (char *) NULL );
3334  sprintf( buf, "%d", digits );
3335  if (argc > 1)
3336  Tcl_SetVar( interp, argv[1+1], buf, 0 );
3337  else
3338  Tcl_AppendResult( interp, buf, (char *) NULL );
3339 
3340  if (pl_errcode != 0) {
3341  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3342  return TCL_ERROR;
3343  }
3344 
3345  plflush();
3346  return TCL_OK;
3347 }
3348 
3349 /*--------------------------------------------------------------------------*\
3350  * plgzaxCmd
3351  *
3352  * Processes plgzax Tcl command.
3353 \*--------------------------------------------------------------------------*/
3354 
3355 static int
3356 plgzaxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3357 {
3358  PLINT digmax;
3359  PLINT digits;
3360 
3361  pl_errcode = 0; errmsg[0] = '\0';
3362 
3363  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3364  Tcl_AppendResult( interp, "command syntax: \"",
3365  "plgzax ?digmax digits?", "\"",
3366  (char *) NULL);
3367  return TCL_ERROR;
3368  }
3369 
3370  if ( (!1 && 0 && (argc < (1 + 2 - 0))) ||
3371  (!1 && !0 && (argc != (2 + 1))) ||
3372  ( 1 && (argc != 1) && (argc != (2 + 1))) ) {
3373  Tcl_AppendResult( interp, "wrong # args: should be \"",
3374  "plgzax ?digmax digits?", "\"",
3375  (char *) NULL);
3376  return TCL_ERROR;
3377  }
3378 
3379 /* digmax is for output. */
3380 /* digits is for output. */
3381 
3382  plgzax ( &digmax, &digits );
3383 
3384  sprintf( buf, "%d", digmax );
3385  if (argc > 1)
3386  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3387  else
3388  Tcl_AppendResult( interp, buf, (char *) NULL );
3389  if (argc == 1)
3390  Tcl_AppendResult( interp, " ", (char *) NULL );
3391  sprintf( buf, "%d", digits );
3392  if (argc > 1)
3393  Tcl_SetVar( interp, argv[1+1], buf, 0 );
3394  else
3395  Tcl_AppendResult( interp, buf, (char *) NULL );
3396 
3397  if (pl_errcode != 0) {
3398  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3399  return TCL_ERROR;
3400  }
3401 
3402  plflush();
3403  return TCL_OK;
3404 }
3405 
3406 /*--------------------------------------------------------------------------*\
3407  * plhistCmd
3408  *
3409  * Processes plhist Tcl command.
3410 \*--------------------------------------------------------------------------*/
3411 
3412 static int
3413 plhistCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3414 {
3415  PLINT n;
3416  PLFLT *data;
3417  tclMatrix *matdata;
3418  PLFLT datmin;
3419  PLFLT datmax;
3420  PLINT nbin;
3421  PLINT oldwin;
3422 
3423  pl_errcode = 0; errmsg[0] = '\0';
3424 
3425  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3426  Tcl_AppendResult( interp, "command syntax: \"",
3427  "plhist n data datmin datmax nbin oldwin", "\"",
3428  (char *) NULL);
3429  return TCL_ERROR;
3430  }
3431 
3432  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
3433  (!0 && !0 && (argc != (6 + 1))) ||
3434  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
3435  Tcl_AppendResult( interp, "wrong # args: should be \"",
3436  "plhist n data datmin datmax nbin oldwin", "\"",
3437  (char *) NULL);
3438  return TCL_ERROR;
3439  }
3440 
3441  n = atoi(argv[1+0]);
3442  matdata = Tcl_GetMatrixPtr( interp, argv[1+1] );
3443  if (matdata == NULL) return TCL_ERROR;
3444  data = matdata->fdata;
3445  datmin = atof(argv[1+2]);
3446  datmax = atof(argv[1+3]);
3447  nbin = atoi(argv[1+4]);
3448  oldwin = atoi(argv[1+5]);
3449 
3450  plhist ( n, data, datmin, datmax, nbin, oldwin );
3451 
3452 
3453  if (pl_errcode != 0) {
3454  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3455  return TCL_ERROR;
3456  }
3457 
3458  plflush();
3459  return TCL_OK;
3460 }
3461 
3462 /*--------------------------------------------------------------------------*\
3463  * plhlsrgbCmd
3464  *
3465  * Processes plhlsrgb Tcl command.
3466 \*--------------------------------------------------------------------------*/
3467 
3468 static int
3469 plhlsrgbCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3470 {
3471  PLFLT h;
3472  PLFLT l;
3473  PLFLT s;
3474  PLFLT r;
3475  PLFLT g;
3476  PLFLT b;
3477 
3478  pl_errcode = 0; errmsg[0] = '\0';
3479 
3480  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3481  Tcl_AppendResult( interp, "command syntax: \"",
3482  "plhlsrgb ?h l s r g b?", "\"",
3483  (char *) NULL);
3484  return TCL_ERROR;
3485  }
3486 
3487  if ( (!1 && 0 && (argc < (1 + 6 - 0))) ||
3488  (!1 && !0 && (argc != (6 + 1))) ||
3489  ( 1 && (argc != 1) && (argc != (6 + 1))) ) {
3490  Tcl_AppendResult( interp, "wrong # args: should be \"",
3491  "plhlsrgb ?h l s r g b?", "\"",
3492  (char *) NULL);
3493  return TCL_ERROR;
3494  }
3495 
3496  h = atof(argv[1+0]);
3497  l = atof(argv[1+1]);
3498  s = atof(argv[1+2]);
3499 /* r is for output. */
3500 /* g is for output. */
3501 /* b is for output. */
3502 
3503  plhlsrgb ( h, l, s, &r, &g, &b );
3504 
3505  if (argc == 1)
3506  Tcl_AppendResult( interp, " ", (char *) NULL );
3507  Tcl_PrintDouble( interp, r, buf );
3508  if (argc > 1)
3509  Tcl_SetVar( interp, argv[1+3], buf, 0 );
3510  else
3511  Tcl_AppendResult( interp, buf, (char *) NULL );
3512  if (argc == 1)
3513  Tcl_AppendResult( interp, " ", (char *) NULL );
3514  Tcl_PrintDouble( interp, g, buf );
3515  if (argc > 1)
3516  Tcl_SetVar( interp, argv[1+4], buf, 0 );
3517  else
3518  Tcl_AppendResult( interp, buf, (char *) NULL );
3519  if (argc == 1)
3520  Tcl_AppendResult( interp, " ", (char *) NULL );
3521  Tcl_PrintDouble( interp, b, buf );
3522  if (argc > 1)
3523  Tcl_SetVar( interp, argv[1+5], buf, 0 );
3524  else
3525  Tcl_AppendResult( interp, buf, (char *) NULL );
3526 
3527  if (pl_errcode != 0) {
3528  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3529  return TCL_ERROR;
3530  }
3531 
3532  plflush();
3533  return TCL_OK;
3534 }
3535 
3536 /*--------------------------------------------------------------------------*\
3537  * plinitCmd
3538  *
3539  * Processes plinit Tcl command.
3540 \*--------------------------------------------------------------------------*/
3541 
3542 static int
3543 plinitCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3544 {
3545 
3546  pl_errcode = 0; errmsg[0] = '\0';
3547 
3548  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3549  Tcl_AppendResult( interp, "command syntax: \"",
3550  "plinit ", "\"",
3551  (char *) NULL);
3552  return TCL_ERROR;
3553  }
3554 
3555  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
3556  (!0 && !0 && (argc != (0 + 1))) ||
3557  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
3558  Tcl_AppendResult( interp, "wrong # args: should be \"",
3559  "plinit ", "\"",
3560  (char *) NULL);
3561  return TCL_ERROR;
3562  }
3563 
3564 
3565  plinit ( );
3566 
3567 
3568  if (pl_errcode != 0) {
3569  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3570  return TCL_ERROR;
3571  }
3572 
3573  plflush();
3574  return TCL_OK;
3575 }
3576 
3577 /*--------------------------------------------------------------------------*\
3578  * pljoinCmd
3579  *
3580  * Processes pljoin Tcl command.
3581 \*--------------------------------------------------------------------------*/
3582 
3583 static int
3584 pljoinCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3585 {
3586  PLFLT x1;
3587  PLFLT y1;
3588  PLFLT x2;
3589  PLFLT y2;
3590 
3591  pl_errcode = 0; errmsg[0] = '\0';
3592 
3593  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3594  Tcl_AppendResult( interp, "command syntax: \"",
3595  "pljoin x1 y1 x2 y2", "\"",
3596  (char *) NULL);
3597  return TCL_ERROR;
3598  }
3599 
3600  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
3601  (!0 && !0 && (argc != (4 + 1))) ||
3602  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
3603  Tcl_AppendResult( interp, "wrong # args: should be \"",
3604  "pljoin x1 y1 x2 y2", "\"",
3605  (char *) NULL);
3606  return TCL_ERROR;
3607  }
3608 
3609  x1 = atof(argv[1+0]);
3610  y1 = atof(argv[1+1]);
3611  x2 = atof(argv[1+2]);
3612  y2 = atof(argv[1+3]);
3613 
3614  pljoin ( x1, y1, x2, y2 );
3615 
3616 
3617  if (pl_errcode != 0) {
3618  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3619  return TCL_ERROR;
3620  }
3621 
3622  plflush();
3623  return TCL_OK;
3624 }
3625 
3626 /*--------------------------------------------------------------------------*\
3627  * pllabCmd
3628  *
3629  * Processes pllab Tcl command.
3630 \*--------------------------------------------------------------------------*/
3631 
3632 static int
3633 pllabCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3634 {
3635  const char *xlabel;
3636  const char *ylabel;
3637  const char *tlabel;
3638 
3639  pl_errcode = 0; errmsg[0] = '\0';
3640 
3641  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3642  Tcl_AppendResult( interp, "command syntax: \"",
3643  "pllab xlabel ylabel tlabel", "\"",
3644  (char *) NULL);
3645  return TCL_ERROR;
3646  }
3647 
3648  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
3649  (!0 && !0 && (argc != (3 + 1))) ||
3650  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
3651  Tcl_AppendResult( interp, "wrong # args: should be \"",
3652  "pllab xlabel ylabel tlabel", "\"",
3653  (char *) NULL);
3654  return TCL_ERROR;
3655  }
3656 
3657  xlabel = argv[1+0];
3658  ylabel = argv[1+1];
3659  tlabel = argv[1+2];
3660 
3661  pllab ( xlabel, ylabel, tlabel );
3662 
3663 
3664  if (pl_errcode != 0) {
3665  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3666  return TCL_ERROR;
3667  }
3668 
3669  plflush();
3670  return TCL_OK;
3671 }
3672 
3673 /*--------------------------------------------------------------------------*\
3674  * pllightsourceCmd
3675  *
3676  * Processes pllightsource Tcl command.
3677 \*--------------------------------------------------------------------------*/
3678 
3679 static int
3680 pllightsourceCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3681 {
3682  PLFLT x;
3683  PLFLT y;
3684  PLFLT z;
3685 
3686  pl_errcode = 0; errmsg[0] = '\0';
3687 
3688  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3689  Tcl_AppendResult( interp, "command syntax: \"",
3690  "pllightsource x y z", "\"",
3691  (char *) NULL);
3692  return TCL_ERROR;
3693  }
3694 
3695  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
3696  (!0 && !0 && (argc != (3 + 1))) ||
3697  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
3698  Tcl_AppendResult( interp, "wrong # args: should be \"",
3699  "pllightsource x y z", "\"",
3700  (char *) NULL);
3701  return TCL_ERROR;
3702  }
3703 
3704  x = atof(argv[1+0]);
3705  y = atof(argv[1+1]);
3706  z = atof(argv[1+2]);
3707 
3708  pllightsource ( x, y, z );
3709 
3710 
3711  if (pl_errcode != 0) {
3712  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3713  return TCL_ERROR;
3714  }
3715 
3716  plflush();
3717  return TCL_OK;
3718 }
3719 
3720 /*--------------------------------------------------------------------------*\
3721  * pllineCmd
3722  *
3723  * Processes plline Tcl command.
3724 \*--------------------------------------------------------------------------*/
3725 
3726 static int
3727 pllineCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3728 {
3729  PLINT n;
3730  PLFLT *x;
3731  tclMatrix *matx;
3732  PLFLT *y;
3733  tclMatrix *maty;
3734 
3735  pl_errcode = 0; errmsg[0] = '\0';
3736 
3737  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3738  Tcl_AppendResult( interp, "command syntax: \"",
3739  "plline n x y", "\"",
3740  (char *) NULL);
3741  return TCL_ERROR;
3742  }
3743 
3744  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
3745  (!0 && !0 && (argc != (3 + 1))) ||
3746  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
3747  Tcl_AppendResult( interp, "wrong # args: should be \"",
3748  "plline n x y", "\"",
3749  (char *) NULL);
3750  return TCL_ERROR;
3751  }
3752 
3753  n = atoi(argv[1+0]);
3754  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
3755  if (matx == NULL) return TCL_ERROR;
3756  x = matx->fdata;
3757  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
3758  if (maty == NULL) return TCL_ERROR;
3759  y = maty->fdata;
3760 
3761  plline ( n, x, y );
3762 
3763 
3764  if (pl_errcode != 0) {
3765  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3766  return TCL_ERROR;
3767  }
3768 
3769  plflush();
3770  return TCL_OK;
3771 }
3772 
3773 /*--------------------------------------------------------------------------*\
3774  * plline3Cmd
3775  *
3776  * Processes plline3 Tcl command.
3777 \*--------------------------------------------------------------------------*/
3778 
3779 static int
3780 plline3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3781 {
3782  PLINT n;
3783  PLFLT *x;
3784  tclMatrix *matx;
3785  PLFLT *y;
3786  tclMatrix *maty;
3787  PLFLT *z;
3788  tclMatrix *matz;
3789 
3790  pl_errcode = 0; errmsg[0] = '\0';
3791 
3792  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3793  Tcl_AppendResult( interp, "command syntax: \"",
3794  "plline3 n x y z", "\"",
3795  (char *) NULL);
3796  return TCL_ERROR;
3797  }
3798 
3799  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
3800  (!0 && !0 && (argc != (4 + 1))) ||
3801  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
3802  Tcl_AppendResult( interp, "wrong # args: should be \"",
3803  "plline3 n x y z", "\"",
3804  (char *) NULL);
3805  return TCL_ERROR;
3806  }
3807 
3808  n = atoi(argv[1+0]);
3809  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
3810  if (matx == NULL) return TCL_ERROR;
3811  x = matx->fdata;
3812  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
3813  if (maty == NULL) return TCL_ERROR;
3814  y = maty->fdata;
3815  matz = Tcl_GetMatrixPtr( interp, argv[1+3] );
3816  if (matz == NULL) return TCL_ERROR;
3817  z = matz->fdata;
3818 
3819  plline3 ( n, x, y, z );
3820 
3821 
3822  if (pl_errcode != 0) {
3823  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3824  return TCL_ERROR;
3825  }
3826 
3827  plflush();
3828  return TCL_OK;
3829 }
3830 
3831 /*--------------------------------------------------------------------------*\
3832  * pllstyCmd
3833  *
3834  * Processes pllsty Tcl command.
3835 \*--------------------------------------------------------------------------*/
3836 
3837 static int
3838 pllstyCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3839 {
3840  PLINT lin;
3841 
3842  pl_errcode = 0; errmsg[0] = '\0';
3843 
3844  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3845  Tcl_AppendResult( interp, "command syntax: \"",
3846  "pllsty lin", "\"",
3847  (char *) NULL);
3848  return TCL_ERROR;
3849  }
3850 
3851  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
3852  (!0 && !0 && (argc != (1 + 1))) ||
3853  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
3854  Tcl_AppendResult( interp, "wrong # args: should be \"",
3855  "pllsty lin", "\"",
3856  (char *) NULL);
3857  return TCL_ERROR;
3858  }
3859 
3860  lin = atoi(argv[1+0]);
3861 
3862  pllsty ( lin );
3863 
3864 
3865  if (pl_errcode != 0) {
3866  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3867  return TCL_ERROR;
3868  }
3869 
3870  plflush();
3871  return TCL_OK;
3872 }
3873 
3874 /*--------------------------------------------------------------------------*\
3875  * plmkstrmCmd
3876  *
3877  * Processes plmkstrm Tcl command.
3878 \*--------------------------------------------------------------------------*/
3879 
3880 static int
3881 plmkstrmCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3882 {
3883  PLINT strm;
3884 
3885  pl_errcode = 0; errmsg[0] = '\0';
3886 
3887  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3888  Tcl_AppendResult( interp, "command syntax: \"",
3889  "plmkstrm ?strm?", "\"",
3890  (char *) NULL);
3891  return TCL_ERROR;
3892  }
3893 
3894  if ( (!1 && 0 && (argc < (1 + 1 - 0))) ||
3895  (!1 && !0 && (argc != (1 + 1))) ||
3896  ( 1 && (argc != 1) && (argc != (1 + 1))) ) {
3897  Tcl_AppendResult( interp, "wrong # args: should be \"",
3898  "plmkstrm ?strm?", "\"",
3899  (char *) NULL);
3900  return TCL_ERROR;
3901  }
3902 
3903 /* strm is for output. */
3904 
3905  plmkstrm ( &strm );
3906 
3907  sprintf( buf, "%d", strm );
3908  if (argc > 1)
3909  Tcl_SetVar( interp, argv[1+0], buf, 0 );
3910  else
3911  Tcl_AppendResult( interp, buf, (char *) NULL );
3912 
3913  if (pl_errcode != 0) {
3914  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3915  return TCL_ERROR;
3916  }
3917 
3918  plflush();
3919  return TCL_OK;
3920 }
3921 
3922 /*--------------------------------------------------------------------------*\
3923  * plmtexCmd
3924  *
3925  * Processes plmtex Tcl command.
3926 \*--------------------------------------------------------------------------*/
3927 
3928 static int
3929 plmtexCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3930 {
3931  const char *side;
3932  PLFLT disp;
3933  PLFLT pos;
3934  PLFLT just;
3935  const char *text;
3936 
3937  pl_errcode = 0; errmsg[0] = '\0';
3938 
3939  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3940  Tcl_AppendResult( interp, "command syntax: \"",
3941  "plmtex side disp pos just text", "\"",
3942  (char *) NULL);
3943  return TCL_ERROR;
3944  }
3945 
3946  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
3947  (!0 && !0 && (argc != (5 + 1))) ||
3948  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
3949  Tcl_AppendResult( interp, "wrong # args: should be \"",
3950  "plmtex side disp pos just text", "\"",
3951  (char *) NULL);
3952  return TCL_ERROR;
3953  }
3954 
3955  side = argv[1+0];
3956  disp = atof(argv[1+1]);
3957  pos = atof(argv[1+2]);
3958  just = atof(argv[1+3]);
3959  text = argv[1+4];
3960 
3961  plmtex ( side, disp, pos, just, text );
3962 
3963 
3964  if (pl_errcode != 0) {
3965  Tcl_AppendResult(interp, errmsg, (char *) NULL);
3966  return TCL_ERROR;
3967  }
3968 
3969  plflush();
3970  return TCL_OK;
3971 }
3972 
3973 /*--------------------------------------------------------------------------*\
3974  * plmtex3Cmd
3975  *
3976  * Processes plmtex3 Tcl command.
3977 \*--------------------------------------------------------------------------*/
3978 
3979 static int
3980 plmtex3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
3981 {
3982  const char *side;
3983  PLFLT disp;
3984  PLFLT pos;
3985  PLFLT just;
3986  const char *text;
3987 
3988  pl_errcode = 0; errmsg[0] = '\0';
3989 
3990  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
3991  Tcl_AppendResult( interp, "command syntax: \"",
3992  "plmtex3 side disp pos just text", "\"",
3993  (char *) NULL);
3994  return TCL_ERROR;
3995  }
3996 
3997  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
3998  (!0 && !0 && (argc != (5 + 1))) ||
3999  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
4000  Tcl_AppendResult( interp, "wrong # args: should be \"",
4001  "plmtex3 side disp pos just text", "\"",
4002  (char *) NULL);
4003  return TCL_ERROR;
4004  }
4005 
4006  side = argv[1+0];
4007  disp = atof(argv[1+1]);
4008  pos = atof(argv[1+2]);
4009  just = atof(argv[1+3]);
4010  text = argv[1+4];
4011 
4012  plmtex3 ( side, disp, pos, just, text );
4013 
4014 
4015  if (pl_errcode != 0) {
4016  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4017  return TCL_ERROR;
4018  }
4019 
4020  plflush();
4021  return TCL_OK;
4022 }
4023 
4024 /*--------------------------------------------------------------------------*\
4025  * plpatCmd
4026  *
4027  * Processes plpat Tcl command.
4028 \*--------------------------------------------------------------------------*/
4029 
4030 static int
4031 plpatCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4032 {
4033  PLINT nlin;
4034  PLINT *inc;
4035  tclMatrix *matinc;
4036  PLINT *del;
4037  tclMatrix *matdel;
4038 
4039  pl_errcode = 0; errmsg[0] = '\0';
4040 
4041  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4042  Tcl_AppendResult( interp, "command syntax: \"",
4043  "plpat nlin inc del", "\"",
4044  (char *) NULL);
4045  return TCL_ERROR;
4046  }
4047 
4048  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
4049  (!0 && !0 && (argc != (3 + 1))) ||
4050  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
4051  Tcl_AppendResult( interp, "wrong # args: should be \"",
4052  "plpat nlin inc del", "\"",
4053  (char *) NULL);
4054  return TCL_ERROR;
4055  }
4056 
4057  nlin = atoi(argv[1+0]);
4058  matinc = Tcl_GetMatrixPtr( interp, argv[1+1] );
4059  if (matinc == NULL) return TCL_ERROR;
4060  inc = matinc->idata;
4061  matdel = Tcl_GetMatrixPtr( interp, argv[1+2] );
4062  if (matdel == NULL) return TCL_ERROR;
4063  del = matdel->idata;
4064 
4065  plpat ( nlin, inc, del );
4066 
4067 
4068  if (pl_errcode != 0) {
4069  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4070  return TCL_ERROR;
4071  }
4072 
4073  plflush();
4074  return TCL_OK;
4075 }
4076 
4077 /*--------------------------------------------------------------------------*\
4078  * plpoinCmd
4079  *
4080  * Processes plpoin Tcl command.
4081 \*--------------------------------------------------------------------------*/
4082 
4083 static int
4084 plpoinCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4085 {
4086  PLINT n;
4087  PLFLT *x;
4088  tclMatrix *matx;
4089  PLFLT *y;
4090  tclMatrix *maty;
4091  PLINT code;
4092 
4093  pl_errcode = 0; errmsg[0] = '\0';
4094 
4095  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4096  Tcl_AppendResult( interp, "command syntax: \"",
4097  "plpoin n x y code", "\"",
4098  (char *) NULL);
4099  return TCL_ERROR;
4100  }
4101 
4102  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
4103  (!0 && !0 && (argc != (4 + 1))) ||
4104  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
4105  Tcl_AppendResult( interp, "wrong # args: should be \"",
4106  "plpoin n x y code", "\"",
4107  (char *) NULL);
4108  return TCL_ERROR;
4109  }
4110 
4111  n = atoi(argv[1+0]);
4112  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
4113  if (matx == NULL) return TCL_ERROR;
4114  x = matx->fdata;
4115  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
4116  if (maty == NULL) return TCL_ERROR;
4117  y = maty->fdata;
4118  code = atoi(argv[1+3]);
4119 
4120  plpoin ( n, x, y, code );
4121 
4122 
4123  if (pl_errcode != 0) {
4124  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4125  return TCL_ERROR;
4126  }
4127 
4128  plflush();
4129  return TCL_OK;
4130 }
4131 
4132 /*--------------------------------------------------------------------------*\
4133  * plpoin3Cmd
4134  *
4135  * Processes plpoin3 Tcl command.
4136 \*--------------------------------------------------------------------------*/
4137 
4138 static int
4139 plpoin3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4140 {
4141  PLINT n;
4142  PLFLT *x;
4143  tclMatrix *matx;
4144  PLFLT *y;
4145  tclMatrix *maty;
4146  PLFLT *z;
4147  tclMatrix *matz;
4148  PLINT code;
4149 
4150  pl_errcode = 0; errmsg[0] = '\0';
4151 
4152  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4153  Tcl_AppendResult( interp, "command syntax: \"",
4154  "plpoin3 n x y z code", "\"",
4155  (char *) NULL);
4156  return TCL_ERROR;
4157  }
4158 
4159  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
4160  (!0 && !0 && (argc != (5 + 1))) ||
4161  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
4162  Tcl_AppendResult( interp, "wrong # args: should be \"",
4163  "plpoin3 n x y z code", "\"",
4164  (char *) NULL);
4165  return TCL_ERROR;
4166  }
4167 
4168  n = atoi(argv[1+0]);
4169  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
4170  if (matx == NULL) return TCL_ERROR;
4171  x = matx->fdata;
4172  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
4173  if (maty == NULL) return TCL_ERROR;
4174  y = maty->fdata;
4175  matz = Tcl_GetMatrixPtr( interp, argv[1+3] );
4176  if (matz == NULL) return TCL_ERROR;
4177  z = matz->fdata;
4178  code = atoi(argv[1+4]);
4179 
4180  plpoin3 ( n, x, y, z, code );
4181 
4182 
4183  if (pl_errcode != 0) {
4184  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4185  return TCL_ERROR;
4186  }
4187 
4188  plflush();
4189  return TCL_OK;
4190 }
4191 
4192 /*--------------------------------------------------------------------------*\
4193  * plpoly3Cmd
4194  *
4195  * Processes plpoly3 Tcl command.
4196 \*--------------------------------------------------------------------------*/
4197 
4198 static int
4199 plpoly3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4200 {
4201  PLINT n;
4202  PLFLT *x;
4203  tclMatrix *matx;
4204  PLFLT *y;
4205  tclMatrix *maty;
4206  PLFLT *z;
4207  tclMatrix *matz;
4208  PLINT *draw;
4209  tclMatrix *matdraw;
4210  PLINT ifcc;
4211 
4212  pl_errcode = 0; errmsg[0] = '\0';
4213 
4214  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4215  Tcl_AppendResult( interp, "command syntax: \"",
4216  "plpoly3 n x y z draw ifcc", "\"",
4217  (char *) NULL);
4218  return TCL_ERROR;
4219  }
4220 
4221  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
4222  (!0 && !0 && (argc != (6 + 1))) ||
4223  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
4224  Tcl_AppendResult( interp, "wrong # args: should be \"",
4225  "plpoly3 n x y z draw ifcc", "\"",
4226  (char *) NULL);
4227  return TCL_ERROR;
4228  }
4229 
4230  n = atoi(argv[1+0]);
4231  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
4232  if (matx == NULL) return TCL_ERROR;
4233  x = matx->fdata;
4234  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
4235  if (maty == NULL) return TCL_ERROR;
4236  y = maty->fdata;
4237  matz = Tcl_GetMatrixPtr( interp, argv[1+3] );
4238  if (matz == NULL) return TCL_ERROR;
4239  z = matz->fdata;
4240  matdraw = Tcl_GetMatrixPtr( interp, argv[1+4] );
4241  if (matdraw == NULL) return TCL_ERROR;
4242  draw = matdraw->idata;
4243  ifcc = atoi(argv[1+5]);
4244 
4245  plpoly3 ( n, x, y, z, draw, ifcc );
4246 
4247 
4248  if (pl_errcode != 0) {
4249  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4250  return TCL_ERROR;
4251  }
4252 
4253  plflush();
4254  return TCL_OK;
4255 }
4256 
4257 /*--------------------------------------------------------------------------*\
4258  * plprecCmd
4259  *
4260  * Processes plprec Tcl command.
4261 \*--------------------------------------------------------------------------*/
4262 
4263 static int
4264 plprecCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4265 {
4266  PLINT setp;
4267  PLINT prec;
4268 
4269  pl_errcode = 0; errmsg[0] = '\0';
4270 
4271  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4272  Tcl_AppendResult( interp, "command syntax: \"",
4273  "plprec setp prec", "\"",
4274  (char *) NULL);
4275  return TCL_ERROR;
4276  }
4277 
4278  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
4279  (!0 && !0 && (argc != (2 + 1))) ||
4280  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
4281  Tcl_AppendResult( interp, "wrong # args: should be \"",
4282  "plprec setp prec", "\"",
4283  (char *) NULL);
4284  return TCL_ERROR;
4285  }
4286 
4287  setp = atoi(argv[1+0]);
4288  prec = atoi(argv[1+1]);
4289 
4290  plprec ( setp, prec );
4291 
4292 
4293  if (pl_errcode != 0) {
4294  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4295  return TCL_ERROR;
4296  }
4297 
4298  plflush();
4299  return TCL_OK;
4300 }
4301 
4302 /*--------------------------------------------------------------------------*\
4303  * plpstyCmd
4304  *
4305  * Processes plpsty Tcl command.
4306 \*--------------------------------------------------------------------------*/
4307 
4308 static int
4309 plpstyCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4310 {
4311  PLINT patt;
4312 
4313  pl_errcode = 0; errmsg[0] = '\0';
4314 
4315  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4316  Tcl_AppendResult( interp, "command syntax: \"",
4317  "plpsty patt", "\"",
4318  (char *) NULL);
4319  return TCL_ERROR;
4320  }
4321 
4322  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
4323  (!0 && !0 && (argc != (1 + 1))) ||
4324  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
4325  Tcl_AppendResult( interp, "wrong # args: should be \"",
4326  "plpsty patt", "\"",
4327  (char *) NULL);
4328  return TCL_ERROR;
4329  }
4330 
4331  patt = atoi(argv[1+0]);
4332 
4333  plpsty ( patt );
4334 
4335 
4336  if (pl_errcode != 0) {
4337  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4338  return TCL_ERROR;
4339  }
4340 
4341  plflush();
4342  return TCL_OK;
4343 }
4344 
4345 /*--------------------------------------------------------------------------*\
4346  * plptexCmd
4347  *
4348  * Processes plptex Tcl command.
4349 \*--------------------------------------------------------------------------*/
4350 
4351 static int
4352 plptexCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4353 {
4354  PLFLT x;
4355  PLFLT y;
4356  PLFLT dx;
4357  PLFLT dy;
4358  PLFLT just;
4359  const char *text;
4360 
4361  pl_errcode = 0; errmsg[0] = '\0';
4362 
4363  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4364  Tcl_AppendResult( interp, "command syntax: \"",
4365  "plptex x y dx dy just text", "\"",
4366  (char *) NULL);
4367  return TCL_ERROR;
4368  }
4369 
4370  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
4371  (!0 && !0 && (argc != (6 + 1))) ||
4372  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
4373  Tcl_AppendResult( interp, "wrong # args: should be \"",
4374  "plptex x y dx dy just text", "\"",
4375  (char *) NULL);
4376  return TCL_ERROR;
4377  }
4378 
4379  x = atof(argv[1+0]);
4380  y = atof(argv[1+1]);
4381  dx = atof(argv[1+2]);
4382  dy = atof(argv[1+3]);
4383  just = atof(argv[1+4]);
4384  text = argv[1+5];
4385 
4386  plptex ( x, y, dx, dy, just, text );
4387 
4388 
4389  if (pl_errcode != 0) {
4390  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4391  return TCL_ERROR;
4392  }
4393 
4394  plflush();
4395  return TCL_OK;
4396 }
4397 
4398 /*--------------------------------------------------------------------------*\
4399  * plptex3Cmd
4400  *
4401  * Processes plptex3 Tcl command.
4402 \*--------------------------------------------------------------------------*/
4403 
4404 static int
4405 plptex3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4406 {
4407  PLFLT wx;
4408  PLFLT wy;
4409  PLFLT wz;
4410  PLFLT dx;
4411  PLFLT dy;
4412  PLFLT dz;
4413  PLFLT sx;
4414  PLFLT sy;
4415  PLFLT sz;
4416  PLFLT just;
4417  const char *text;
4418 
4419  pl_errcode = 0; errmsg[0] = '\0';
4420 
4421  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4422  Tcl_AppendResult( interp, "command syntax: \"",
4423  "plptex3 wx wy wz dx dy dz sx sy sz just text", "\"",
4424  (char *) NULL);
4425  return TCL_ERROR;
4426  }
4427 
4428  if ( (!0 && 0 && (argc < (1 + 11 - 0))) ||
4429  (!0 && !0 && (argc != (11 + 1))) ||
4430  ( 0 && (argc != 1) && (argc != (11 + 1))) ) {
4431  Tcl_AppendResult( interp, "wrong # args: should be \"",
4432  "plptex3 wx wy wz dx dy dz sx sy sz just text", "\"",
4433  (char *) NULL);
4434  return TCL_ERROR;
4435  }
4436 
4437  wx = atof(argv[1+0]);
4438  wy = atof(argv[1+1]);
4439  wz = atof(argv[1+2]);
4440  dx = atof(argv[1+3]);
4441  dy = atof(argv[1+4]);
4442  dz = atof(argv[1+5]);
4443  sx = atof(argv[1+6]);
4444  sy = atof(argv[1+7]);
4445  sz = atof(argv[1+8]);
4446  just = atof(argv[1+9]);
4447  text = argv[1+10];
4448 
4449  plptex3 ( wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text );
4450 
4451 
4452  if (pl_errcode != 0) {
4453  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4454  return TCL_ERROR;
4455  }
4456 
4457  plflush();
4458  return TCL_OK;
4459 }
4460 
4461 /*--------------------------------------------------------------------------*\
4462  * plreplotCmd
4463  *
4464  * Processes plreplot Tcl command.
4465 \*--------------------------------------------------------------------------*/
4466 
4467 static int
4468 plreplotCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4469 {
4470 
4471  pl_errcode = 0; errmsg[0] = '\0';
4472 
4473  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4474  Tcl_AppendResult( interp, "command syntax: \"",
4475  "plreplot ", "\"",
4476  (char *) NULL);
4477  return TCL_ERROR;
4478  }
4479 
4480  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
4481  (!0 && !0 && (argc != (0 + 1))) ||
4482  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
4483  Tcl_AppendResult( interp, "wrong # args: should be \"",
4484  "plreplot ", "\"",
4485  (char *) NULL);
4486  return TCL_ERROR;
4487  }
4488 
4489 
4490  plreplot ( );
4491 
4492 
4493  if (pl_errcode != 0) {
4494  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4495  return TCL_ERROR;
4496  }
4497 
4498  plflush();
4499  return TCL_OK;
4500 }
4501 
4502 /*--------------------------------------------------------------------------*\
4503  * plrgbhlsCmd
4504  *
4505  * Processes plrgbhls Tcl command.
4506 \*--------------------------------------------------------------------------*/
4507 
4508 static int
4509 plrgbhlsCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4510 {
4511  PLFLT r;
4512  PLFLT g;
4513  PLFLT b;
4514  PLFLT h;
4515  PLFLT l;
4516  PLFLT s;
4517 
4518  pl_errcode = 0; errmsg[0] = '\0';
4519 
4520  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4521  Tcl_AppendResult( interp, "command syntax: \"",
4522  "plrgbhls ?r g b h l s?", "\"",
4523  (char *) NULL);
4524  return TCL_ERROR;
4525  }
4526 
4527  if ( (!1 && 0 && (argc < (1 + 6 - 0))) ||
4528  (!1 && !0 && (argc != (6 + 1))) ||
4529  ( 1 && (argc != 1) && (argc != (6 + 1))) ) {
4530  Tcl_AppendResult( interp, "wrong # args: should be \"",
4531  "plrgbhls ?r g b h l s?", "\"",
4532  (char *) NULL);
4533  return TCL_ERROR;
4534  }
4535 
4536  r = atof(argv[1+0]);
4537  g = atof(argv[1+1]);
4538  b = atof(argv[1+2]);
4539 /* h is for output. */
4540 /* l is for output. */
4541 /* s is for output. */
4542 
4543  plrgbhls ( r, g, b, &h, &l, &s );
4544 
4545  if (argc == 1)
4546  Tcl_AppendResult( interp, " ", (char *) NULL );
4547  Tcl_PrintDouble( interp, h, buf );
4548  if (argc > 1)
4549  Tcl_SetVar( interp, argv[1+3], buf, 0 );
4550  else
4551  Tcl_AppendResult( interp, buf, (char *) NULL );
4552  if (argc == 1)
4553  Tcl_AppendResult( interp, " ", (char *) NULL );
4554  Tcl_PrintDouble( interp, l, buf );
4555  if (argc > 1)
4556  Tcl_SetVar( interp, argv[1+4], buf, 0 );
4557  else
4558  Tcl_AppendResult( interp, buf, (char *) NULL );
4559  if (argc == 1)
4560  Tcl_AppendResult( interp, " ", (char *) NULL );
4561  Tcl_PrintDouble( interp, s, buf );
4562  if (argc > 1)
4563  Tcl_SetVar( interp, argv[1+5], buf, 0 );
4564  else
4565  Tcl_AppendResult( interp, buf, (char *) NULL );
4566 
4567  if (pl_errcode != 0) {
4568  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4569  return TCL_ERROR;
4570  }
4571 
4572  plflush();
4573  return TCL_OK;
4574 }
4575 
4576 /*--------------------------------------------------------------------------*\
4577  * plschrCmd
4578  *
4579  * Processes plschr Tcl command.
4580 \*--------------------------------------------------------------------------*/
4581 
4582 static int
4583 plschrCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4584 {
4585  PLFLT def;
4586  PLFLT scale;
4587 
4588  pl_errcode = 0; errmsg[0] = '\0';
4589 
4590  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4591  Tcl_AppendResult( interp, "command syntax: \"",
4592  "plschr def scale", "\"",
4593  (char *) NULL);
4594  return TCL_ERROR;
4595  }
4596 
4597  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
4598  (!0 && !0 && (argc != (2 + 1))) ||
4599  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
4600  Tcl_AppendResult( interp, "wrong # args: should be \"",
4601  "plschr def scale", "\"",
4602  (char *) NULL);
4603  return TCL_ERROR;
4604  }
4605 
4606  def = atof(argv[1+0]);
4607  scale = atof(argv[1+1]);
4608 
4609  plschr ( def, scale );
4610 
4611 
4612  if (pl_errcode != 0) {
4613  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4614  return TCL_ERROR;
4615  }
4616 
4617  plflush();
4618  return TCL_OK;
4619 }
4620 
4621 /*--------------------------------------------------------------------------*\
4622  * plscmap0Cmd
4623  *
4624  * Processes plscmap0 Tcl command.
4625 \*--------------------------------------------------------------------------*/
4626 
4627 static int
4628 plscmap0Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4629 {
4630  PLINT *r;
4631  tclMatrix *matr;
4632  PLINT *g;
4633  tclMatrix *matg;
4634  PLINT *b;
4635  tclMatrix *matb;
4636  PLINT ncol0;
4637 
4638  pl_errcode = 0; errmsg[0] = '\0';
4639 
4640  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4641  Tcl_AppendResult( interp, "command syntax: \"",
4642  "plscmap0 r g b ncol0", "\"",
4643  (char *) NULL);
4644  return TCL_ERROR;
4645  }
4646 
4647  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
4648  (!0 && !0 && (argc != (4 + 1))) ||
4649  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
4650  Tcl_AppendResult( interp, "wrong # args: should be \"",
4651  "plscmap0 r g b ncol0", "\"",
4652  (char *) NULL);
4653  return TCL_ERROR;
4654  }
4655 
4656  matr = Tcl_GetMatrixPtr( interp, argv[1+0] );
4657  if (matr == NULL) return TCL_ERROR;
4658  r = matr->idata;
4659  matg = Tcl_GetMatrixPtr( interp, argv[1+1] );
4660  if (matg == NULL) return TCL_ERROR;
4661  g = matg->idata;
4662  matb = Tcl_GetMatrixPtr( interp, argv[1+2] );
4663  if (matb == NULL) return TCL_ERROR;
4664  b = matb->idata;
4665  ncol0 = atoi(argv[1+3]);
4666 
4667  plscmap0 ( r, g, b, ncol0 );
4668 
4669 
4670  if (pl_errcode != 0) {
4671  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4672  return TCL_ERROR;
4673  }
4674 
4675  plflush();
4676  return TCL_OK;
4677 }
4678 
4679 /*--------------------------------------------------------------------------*\
4680  * plscmap0aCmd
4681  *
4682  * Processes plscmap0a Tcl command.
4683 \*--------------------------------------------------------------------------*/
4684 
4685 static int
4686 plscmap0aCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4687 {
4688  PLINT *r;
4689  tclMatrix *matr;
4690  PLINT *g;
4691  tclMatrix *matg;
4692  PLINT *b;
4693  tclMatrix *matb;
4694  PLFLT *a;
4695  tclMatrix *mata;
4696  PLINT ncol0;
4697 
4698  pl_errcode = 0; errmsg[0] = '\0';
4699 
4700  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4701  Tcl_AppendResult( interp, "command syntax: \"",
4702  "plscmap0a r g b a ncol0", "\"",
4703  (char *) NULL);
4704  return TCL_ERROR;
4705  }
4706 
4707  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
4708  (!0 && !0 && (argc != (5 + 1))) ||
4709  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
4710  Tcl_AppendResult( interp, "wrong # args: should be \"",
4711  "plscmap0a r g b a ncol0", "\"",
4712  (char *) NULL);
4713  return TCL_ERROR;
4714  }
4715 
4716  matr = Tcl_GetMatrixPtr( interp, argv[1+0] );
4717  if (matr == NULL) return TCL_ERROR;
4718  r = matr->idata;
4719  matg = Tcl_GetMatrixPtr( interp, argv[1+1] );
4720  if (matg == NULL) return TCL_ERROR;
4721  g = matg->idata;
4722  matb = Tcl_GetMatrixPtr( interp, argv[1+2] );
4723  if (matb == NULL) return TCL_ERROR;
4724  b = matb->idata;
4725  mata = Tcl_GetMatrixPtr( interp, argv[1+3] );
4726  if (mata == NULL) return TCL_ERROR;
4727  a = mata->fdata;
4728  ncol0 = atoi(argv[1+4]);
4729 
4730  plscmap0a ( r, g, b, a, ncol0 );
4731 
4732 
4733  if (pl_errcode != 0) {
4734  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4735  return TCL_ERROR;
4736  }
4737 
4738  plflush();
4739  return TCL_OK;
4740 }
4741 
4742 /*--------------------------------------------------------------------------*\
4743  * plscmap0nCmd
4744  *
4745  * Processes plscmap0n Tcl command.
4746 \*--------------------------------------------------------------------------*/
4747 
4748 static int
4749 plscmap0nCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4750 {
4751  PLINT ncol0;
4752 
4753  pl_errcode = 0; errmsg[0] = '\0';
4754 
4755  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4756  Tcl_AppendResult( interp, "command syntax: \"",
4757  "plscmap0n ncol0", "\"",
4758  (char *) NULL);
4759  return TCL_ERROR;
4760  }
4761 
4762  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
4763  (!0 && !0 && (argc != (1 + 1))) ||
4764  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
4765  Tcl_AppendResult( interp, "wrong # args: should be \"",
4766  "plscmap0n ncol0", "\"",
4767  (char *) NULL);
4768  return TCL_ERROR;
4769  }
4770 
4771  ncol0 = atoi(argv[1+0]);
4772 
4773  plscmap0n ( ncol0 );
4774 
4775 
4776  if (pl_errcode != 0) {
4777  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4778  return TCL_ERROR;
4779  }
4780 
4781  plflush();
4782  return TCL_OK;
4783 }
4784 
4785 /*--------------------------------------------------------------------------*\
4786  * plscmap1Cmd
4787  *
4788  * Processes plscmap1 Tcl command.
4789 \*--------------------------------------------------------------------------*/
4790 
4791 static int
4792 plscmap1Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4793 {
4794  PLINT *r;
4795  tclMatrix *matr;
4796  PLINT *g;
4797  tclMatrix *matg;
4798  PLINT *b;
4799  tclMatrix *matb;
4800  PLINT ncol1;
4801 
4802  pl_errcode = 0; errmsg[0] = '\0';
4803 
4804  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4805  Tcl_AppendResult( interp, "command syntax: \"",
4806  "plscmap1 r g b ncol1", "\"",
4807  (char *) NULL);
4808  return TCL_ERROR;
4809  }
4810 
4811  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
4812  (!0 && !0 && (argc != (4 + 1))) ||
4813  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
4814  Tcl_AppendResult( interp, "wrong # args: should be \"",
4815  "plscmap1 r g b ncol1", "\"",
4816  (char *) NULL);
4817  return TCL_ERROR;
4818  }
4819 
4820  matr = Tcl_GetMatrixPtr( interp, argv[1+0] );
4821  if (matr == NULL) return TCL_ERROR;
4822  r = matr->idata;
4823  matg = Tcl_GetMatrixPtr( interp, argv[1+1] );
4824  if (matg == NULL) return TCL_ERROR;
4825  g = matg->idata;
4826  matb = Tcl_GetMatrixPtr( interp, argv[1+2] );
4827  if (matb == NULL) return TCL_ERROR;
4828  b = matb->idata;
4829  ncol1 = atoi(argv[1+3]);
4830 
4831  plscmap1 ( r, g, b, ncol1 );
4832 
4833 
4834  if (pl_errcode != 0) {
4835  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4836  return TCL_ERROR;
4837  }
4838 
4839  plflush();
4840  return TCL_OK;
4841 }
4842 
4843 /*--------------------------------------------------------------------------*\
4844  * plscmap1aCmd
4845  *
4846  * Processes plscmap1a Tcl command.
4847 \*--------------------------------------------------------------------------*/
4848 
4849 static int
4850 plscmap1aCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4851 {
4852  PLINT *r;
4853  tclMatrix *matr;
4854  PLINT *g;
4855  tclMatrix *matg;
4856  PLINT *b;
4857  tclMatrix *matb;
4858  PLFLT *a;
4859  tclMatrix *mata;
4860  PLINT ncol1;
4861 
4862  pl_errcode = 0; errmsg[0] = '\0';
4863 
4864  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4865  Tcl_AppendResult( interp, "command syntax: \"",
4866  "plscmap1a r g b a ncol1", "\"",
4867  (char *) NULL);
4868  return TCL_ERROR;
4869  }
4870 
4871  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
4872  (!0 && !0 && (argc != (5 + 1))) ||
4873  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
4874  Tcl_AppendResult( interp, "wrong # args: should be \"",
4875  "plscmap1a r g b a ncol1", "\"",
4876  (char *) NULL);
4877  return TCL_ERROR;
4878  }
4879 
4880  matr = Tcl_GetMatrixPtr( interp, argv[1+0] );
4881  if (matr == NULL) return TCL_ERROR;
4882  r = matr->idata;
4883  matg = Tcl_GetMatrixPtr( interp, argv[1+1] );
4884  if (matg == NULL) return TCL_ERROR;
4885  g = matg->idata;
4886  matb = Tcl_GetMatrixPtr( interp, argv[1+2] );
4887  if (matb == NULL) return TCL_ERROR;
4888  b = matb->idata;
4889  mata = Tcl_GetMatrixPtr( interp, argv[1+3] );
4890  if (mata == NULL) return TCL_ERROR;
4891  a = mata->fdata;
4892  ncol1 = atoi(argv[1+4]);
4893 
4894  plscmap1a ( r, g, b, a, ncol1 );
4895 
4896 
4897  if (pl_errcode != 0) {
4898  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4899  return TCL_ERROR;
4900  }
4901 
4902  plflush();
4903  return TCL_OK;
4904 }
4905 
4906 /*--------------------------------------------------------------------------*\
4907  * plscmap1lCmd
4908  *
4909  * Processes plscmap1l Tcl command.
4910 \*--------------------------------------------------------------------------*/
4911 
4912 static int
4913 plscmap1lCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4914 {
4915  PLINT itype;
4916  PLINT npts;
4917  PLFLT *intensity;
4918  tclMatrix *matintensity;
4919  PLFLT *coord1;
4920  tclMatrix *matcoord1;
4921  PLFLT *coord2;
4922  tclMatrix *matcoord2;
4923  PLFLT *coord3;
4924  tclMatrix *matcoord3;
4925  PLINT *alt_hue_path;
4926  tclMatrix *matalt_hue_path;
4927 
4928  pl_errcode = 0; errmsg[0] = '\0';
4929 
4930  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
4931  Tcl_AppendResult( interp, "command syntax: \"",
4932  "plscmap1l itype npts intensity coord1 coord2 coord3 alt_hue_path", "\"",
4933  (char *) NULL);
4934  return TCL_ERROR;
4935  }
4936 
4937  if ( (!0 && 0 && (argc < (1 + 7 - 0))) ||
4938  (!0 && !0 && (argc != (7 + 1))) ||
4939  ( 0 && (argc != 1) && (argc != (7 + 1))) ) {
4940  Tcl_AppendResult( interp, "wrong # args: should be \"",
4941  "plscmap1l itype npts intensity coord1 coord2 coord3 alt_hue_path", "\"",
4942  (char *) NULL);
4943  return TCL_ERROR;
4944  }
4945 
4946  itype = atoi(argv[1+0]);
4947  npts = atoi(argv[1+1]);
4948  matintensity = Tcl_GetMatrixPtr( interp, argv[1+2] );
4949  if (matintensity == NULL) return TCL_ERROR;
4950  intensity = matintensity->fdata;
4951  matcoord1 = Tcl_GetMatrixPtr( interp, argv[1+3] );
4952  if (matcoord1 == NULL) return TCL_ERROR;
4953  coord1 = matcoord1->fdata;
4954  matcoord2 = Tcl_GetMatrixPtr( interp, argv[1+4] );
4955  if (matcoord2 == NULL) return TCL_ERROR;
4956  coord2 = matcoord2->fdata;
4957  matcoord3 = Tcl_GetMatrixPtr( interp, argv[1+5] );
4958  if (matcoord3 == NULL) return TCL_ERROR;
4959  coord3 = matcoord3->fdata;
4960  matalt_hue_path = Tcl_GetMatrixPtr( interp, argv[1+6] );
4961  if (matalt_hue_path == NULL) return TCL_ERROR;
4962  alt_hue_path = matalt_hue_path->idata;
4963 
4964  plscmap1l ( itype, npts, intensity, coord1, coord2, coord3, alt_hue_path );
4965 
4966 
4967  if (pl_errcode != 0) {
4968  Tcl_AppendResult(interp, errmsg, (char *) NULL);
4969  return TCL_ERROR;
4970  }
4971 
4972  plflush();
4973  return TCL_OK;
4974 }
4975 
4976 /*--------------------------------------------------------------------------*\
4977  * plscmap1laCmd
4978  *
4979  * Processes plscmap1la Tcl command.
4980 \*--------------------------------------------------------------------------*/
4981 
4982 static int
4983 plscmap1laCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
4984 {
4985  PLINT itype;
4986  PLINT npts;
4987  PLFLT *intensity;
4988  tclMatrix *matintensity;
4989  PLFLT *coord1;
4990  tclMatrix *matcoord1;
4991  PLFLT *coord2;
4992  tclMatrix *matcoord2;
4993  PLFLT *coord3;
4994  tclMatrix *matcoord3;
4995  PLFLT *a;
4996  tclMatrix *mata;
4997  PLINT *alt_hue_path;
4998  tclMatrix *matalt_hue_path;
4999 
5000  pl_errcode = 0; errmsg[0] = '\0';
5001 
5002  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5003  Tcl_AppendResult( interp, "command syntax: \"",
5004  "plscmap1la itype npts intensity coord1 coord2 coord3 a alt_hue_path", "\"",
5005  (char *) NULL);
5006  return TCL_ERROR;
5007  }
5008 
5009  if ( (!0 && 0 && (argc < (1 + 8 - 0))) ||
5010  (!0 && !0 && (argc != (8 + 1))) ||
5011  ( 0 && (argc != 1) && (argc != (8 + 1))) ) {
5012  Tcl_AppendResult( interp, "wrong # args: should be \"",
5013  "plscmap1la itype npts intensity coord1 coord2 coord3 a alt_hue_path", "\"",
5014  (char *) NULL);
5015  return TCL_ERROR;
5016  }
5017 
5018  itype = atoi(argv[1+0]);
5019  npts = atoi(argv[1+1]);
5020  matintensity = Tcl_GetMatrixPtr( interp, argv[1+2] );
5021  if (matintensity == NULL) return TCL_ERROR;
5022  intensity = matintensity->fdata;
5023  matcoord1 = Tcl_GetMatrixPtr( interp, argv[1+3] );
5024  if (matcoord1 == NULL) return TCL_ERROR;
5025  coord1 = matcoord1->fdata;
5026  matcoord2 = Tcl_GetMatrixPtr( interp, argv[1+4] );
5027  if (matcoord2 == NULL) return TCL_ERROR;
5028  coord2 = matcoord2->fdata;
5029  matcoord3 = Tcl_GetMatrixPtr( interp, argv[1+5] );
5030  if (matcoord3 == NULL) return TCL_ERROR;
5031  coord3 = matcoord3->fdata;
5032  mata = Tcl_GetMatrixPtr( interp, argv[1+6] );
5033  if (mata == NULL) return TCL_ERROR;
5034  a = mata->fdata;
5035  matalt_hue_path = Tcl_GetMatrixPtr( interp, argv[1+7] );
5036  if (matalt_hue_path == NULL) return TCL_ERROR;
5037  alt_hue_path = matalt_hue_path->idata;
5038 
5039  plscmap1la ( itype, npts, intensity, coord1, coord2, coord3, a, alt_hue_path );
5040 
5041 
5042  if (pl_errcode != 0) {
5043  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5044  return TCL_ERROR;
5045  }
5046 
5047  plflush();
5048  return TCL_OK;
5049 }
5050 
5051 /*--------------------------------------------------------------------------*\
5052  * plscmap1nCmd
5053  *
5054  * Processes plscmap1n Tcl command.
5055 \*--------------------------------------------------------------------------*/
5056 
5057 static int
5058 plscmap1nCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5059 {
5060  PLINT ncol1;
5061 
5062  pl_errcode = 0; errmsg[0] = '\0';
5063 
5064  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5065  Tcl_AppendResult( interp, "command syntax: \"",
5066  "plscmap1n ncol1", "\"",
5067  (char *) NULL);
5068  return TCL_ERROR;
5069  }
5070 
5071  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5072  (!0 && !0 && (argc != (1 + 1))) ||
5073  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5074  Tcl_AppendResult( interp, "wrong # args: should be \"",
5075  "plscmap1n ncol1", "\"",
5076  (char *) NULL);
5077  return TCL_ERROR;
5078  }
5079 
5080  ncol1 = atoi(argv[1+0]);
5081 
5082  plscmap1n ( ncol1 );
5083 
5084 
5085  if (pl_errcode != 0) {
5086  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5087  return TCL_ERROR;
5088  }
5089 
5090  plflush();
5091  return TCL_OK;
5092 }
5093 
5094 /*--------------------------------------------------------------------------*\
5095  * plscmap1_rangeCmd
5096  *
5097  * Processes plscmap1_range Tcl command.
5098 \*--------------------------------------------------------------------------*/
5099 
5100 static int
5101 plscmap1_rangeCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5102 {
5103  PLFLT min_color;
5104  PLFLT max_color;
5105 
5106  pl_errcode = 0; errmsg[0] = '\0';
5107 
5108  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5109  Tcl_AppendResult( interp, "command syntax: \"",
5110  "plscmap1_range min_color max_color", "\"",
5111  (char *) NULL);
5112  return TCL_ERROR;
5113  }
5114 
5115  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
5116  (!0 && !0 && (argc != (2 + 1))) ||
5117  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
5118  Tcl_AppendResult( interp, "wrong # args: should be \"",
5119  "plscmap1_range min_color max_color", "\"",
5120  (char *) NULL);
5121  return TCL_ERROR;
5122  }
5123 
5124  min_color = atof(argv[1+0]);
5125  max_color = atof(argv[1+1]);
5126 
5127  plscmap1_range ( min_color, max_color );
5128 
5129 
5130  if (pl_errcode != 0) {
5131  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5132  return TCL_ERROR;
5133  }
5134 
5135  plflush();
5136  return TCL_OK;
5137 }
5138 
5139 /*--------------------------------------------------------------------------*\
5140  * plscol0Cmd
5141  *
5142  * Processes plscol0 Tcl command.
5143 \*--------------------------------------------------------------------------*/
5144 
5145 static int
5146 plscol0Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5147 {
5148  PLINT icol0;
5149  PLINT r;
5150  PLINT g;
5151  PLINT b;
5152 
5153  pl_errcode = 0; errmsg[0] = '\0';
5154 
5155  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5156  Tcl_AppendResult( interp, "command syntax: \"",
5157  "plscol0 icol0 r g b", "\"",
5158  (char *) NULL);
5159  return TCL_ERROR;
5160  }
5161 
5162  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
5163  (!0 && !0 && (argc != (4 + 1))) ||
5164  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
5165  Tcl_AppendResult( interp, "wrong # args: should be \"",
5166  "plscol0 icol0 r g b", "\"",
5167  (char *) NULL);
5168  return TCL_ERROR;
5169  }
5170 
5171  icol0 = atoi(argv[1+0]);
5172  r = atoi(argv[1+1]);
5173  g = atoi(argv[1+2]);
5174  b = atoi(argv[1+3]);
5175 
5176  plscol0 ( icol0, r, g, b );
5177 
5178 
5179  if (pl_errcode != 0) {
5180  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5181  return TCL_ERROR;
5182  }
5183 
5184  plflush();
5185  return TCL_OK;
5186 }
5187 
5188 /*--------------------------------------------------------------------------*\
5189  * plscol0aCmd
5190  *
5191  * Processes plscol0a Tcl command.
5192 \*--------------------------------------------------------------------------*/
5193 
5194 static int
5195 plscol0aCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5196 {
5197  PLINT icol0;
5198  PLINT r;
5199  PLINT g;
5200  PLINT b;
5201  PLFLT a;
5202 
5203  pl_errcode = 0; errmsg[0] = '\0';
5204 
5205  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5206  Tcl_AppendResult( interp, "command syntax: \"",
5207  "plscol0a icol0 r g b a", "\"",
5208  (char *) NULL);
5209  return TCL_ERROR;
5210  }
5211 
5212  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
5213  (!0 && !0 && (argc != (5 + 1))) ||
5214  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
5215  Tcl_AppendResult( interp, "wrong # args: should be \"",
5216  "plscol0a icol0 r g b a", "\"",
5217  (char *) NULL);
5218  return TCL_ERROR;
5219  }
5220 
5221  icol0 = atoi(argv[1+0]);
5222  r = atoi(argv[1+1]);
5223  g = atoi(argv[1+2]);
5224  b = atoi(argv[1+3]);
5225  a = atof(argv[1+4]);
5226 
5227  plscol0a ( icol0, r, g, b, a );
5228 
5229 
5230  if (pl_errcode != 0) {
5231  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5232  return TCL_ERROR;
5233  }
5234 
5235  plflush();
5236  return TCL_OK;
5237 }
5238 
5239 /*--------------------------------------------------------------------------*\
5240  * plscolbgCmd
5241  *
5242  * Processes plscolbg Tcl command.
5243 \*--------------------------------------------------------------------------*/
5244 
5245 static int
5246 plscolbgCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5247 {
5248  PLINT r;
5249  PLINT g;
5250  PLINT b;
5251 
5252  pl_errcode = 0; errmsg[0] = '\0';
5253 
5254  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5255  Tcl_AppendResult( interp, "command syntax: \"",
5256  "plscolbg r g b", "\"",
5257  (char *) NULL);
5258  return TCL_ERROR;
5259  }
5260 
5261  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
5262  (!0 && !0 && (argc != (3 + 1))) ||
5263  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
5264  Tcl_AppendResult( interp, "wrong # args: should be \"",
5265  "plscolbg r g b", "\"",
5266  (char *) NULL);
5267  return TCL_ERROR;
5268  }
5269 
5270  r = atoi(argv[1+0]);
5271  g = atoi(argv[1+1]);
5272  b = atoi(argv[1+2]);
5273 
5274  plscolbg ( r, g, b );
5275 
5276 
5277  if (pl_errcode != 0) {
5278  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5279  return TCL_ERROR;
5280  }
5281 
5282  plflush();
5283  return TCL_OK;
5284 }
5285 
5286 /*--------------------------------------------------------------------------*\
5287  * plscolbgaCmd
5288  *
5289  * Processes plscolbga Tcl command.
5290 \*--------------------------------------------------------------------------*/
5291 
5292 static int
5293 plscolbgaCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5294 {
5295  PLINT r;
5296  PLINT g;
5297  PLINT b;
5298  PLFLT a;
5299 
5300  pl_errcode = 0; errmsg[0] = '\0';
5301 
5302  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5303  Tcl_AppendResult( interp, "command syntax: \"",
5304  "plscolbga r g b a", "\"",
5305  (char *) NULL);
5306  return TCL_ERROR;
5307  }
5308 
5309  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
5310  (!0 && !0 && (argc != (4 + 1))) ||
5311  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
5312  Tcl_AppendResult( interp, "wrong # args: should be \"",
5313  "plscolbga r g b a", "\"",
5314  (char *) NULL);
5315  return TCL_ERROR;
5316  }
5317 
5318  r = atoi(argv[1+0]);
5319  g = atoi(argv[1+1]);
5320  b = atoi(argv[1+2]);
5321  a = atof(argv[1+3]);
5322 
5323  plscolbga ( r, g, b, a );
5324 
5325 
5326  if (pl_errcode != 0) {
5327  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5328  return TCL_ERROR;
5329  }
5330 
5331  plflush();
5332  return TCL_OK;
5333 }
5334 
5335 /*--------------------------------------------------------------------------*\
5336  * plscolorCmd
5337  *
5338  * Processes plscolor Tcl command.
5339 \*--------------------------------------------------------------------------*/
5340 
5341 static int
5342 plscolorCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5343 {
5344  PLINT color;
5345 
5346  pl_errcode = 0; errmsg[0] = '\0';
5347 
5348  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5349  Tcl_AppendResult( interp, "command syntax: \"",
5350  "plscolor color", "\"",
5351  (char *) NULL);
5352  return TCL_ERROR;
5353  }
5354 
5355  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5356  (!0 && !0 && (argc != (1 + 1))) ||
5357  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5358  Tcl_AppendResult( interp, "wrong # args: should be \"",
5359  "plscolor color", "\"",
5360  (char *) NULL);
5361  return TCL_ERROR;
5362  }
5363 
5364  color = atoi(argv[1+0]);
5365 
5366  plscolor ( color );
5367 
5368 
5369  if (pl_errcode != 0) {
5370  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5371  return TCL_ERROR;
5372  }
5373 
5374  plflush();
5375  return TCL_OK;
5376 }
5377 
5378 /*--------------------------------------------------------------------------*\
5379  * plscompressionCmd
5380  *
5381  * Processes plscompression Tcl command.
5382 \*--------------------------------------------------------------------------*/
5383 
5384 static int
5385 plscompressionCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5386 {
5387  PLINT compression;
5388 
5389  pl_errcode = 0; errmsg[0] = '\0';
5390 
5391  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5392  Tcl_AppendResult( interp, "command syntax: \"",
5393  "plscompression compression", "\"",
5394  (char *) NULL);
5395  return TCL_ERROR;
5396  }
5397 
5398  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5399  (!0 && !0 && (argc != (1 + 1))) ||
5400  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5401  Tcl_AppendResult( interp, "wrong # args: should be \"",
5402  "plscompression compression", "\"",
5403  (char *) NULL);
5404  return TCL_ERROR;
5405  }
5406 
5407  compression = atoi(argv[1+0]);
5408 
5409  plscompression ( compression );
5410 
5411 
5412  if (pl_errcode != 0) {
5413  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5414  return TCL_ERROR;
5415  }
5416 
5417  plflush();
5418  return TCL_OK;
5419 }
5420 
5421 /*--------------------------------------------------------------------------*\
5422  * plsdevCmd
5423  *
5424  * Processes plsdev Tcl command.
5425 \*--------------------------------------------------------------------------*/
5426 
5427 static int
5428 plsdevCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5429 {
5430  const char *devnam;
5431 
5432  pl_errcode = 0; errmsg[0] = '\0';
5433 
5434  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5435  Tcl_AppendResult( interp, "command syntax: \"",
5436  "plsdev devnam", "\"",
5437  (char *) NULL);
5438  return TCL_ERROR;
5439  }
5440 
5441  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5442  (!0 && !0 && (argc != (1 + 1))) ||
5443  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5444  Tcl_AppendResult( interp, "wrong # args: should be \"",
5445  "plsdev devnam", "\"",
5446  (char *) NULL);
5447  return TCL_ERROR;
5448  }
5449 
5450  devnam = argv[1+0];
5451 
5452  plsdev ( devnam );
5453 
5454 
5455  if (pl_errcode != 0) {
5456  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5457  return TCL_ERROR;
5458  }
5459 
5460  plflush();
5461  return TCL_OK;
5462 }
5463 
5464 /*--------------------------------------------------------------------------*\
5465  * plsdidevCmd
5466  *
5467  * Processes plsdidev Tcl command.
5468 \*--------------------------------------------------------------------------*/
5469 
5470 static int
5471 plsdidevCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5472 {
5473  PLFLT mar;
5474  PLFLT aspect;
5475  PLFLT jx;
5476  PLFLT jy;
5477 
5478  pl_errcode = 0; errmsg[0] = '\0';
5479 
5480  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5481  Tcl_AppendResult( interp, "command syntax: \"",
5482  "plsdidev mar aspect jx jy", "\"",
5483  (char *) NULL);
5484  return TCL_ERROR;
5485  }
5486 
5487  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
5488  (!0 && !0 && (argc != (4 + 1))) ||
5489  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
5490  Tcl_AppendResult( interp, "wrong # args: should be \"",
5491  "plsdidev mar aspect jx jy", "\"",
5492  (char *) NULL);
5493  return TCL_ERROR;
5494  }
5495 
5496  mar = atof(argv[1+0]);
5497  aspect = atof(argv[1+1]);
5498  jx = atof(argv[1+2]);
5499  jy = atof(argv[1+3]);
5500 
5501  plsdidev ( mar, aspect, jx, jy );
5502 
5503 
5504  if (pl_errcode != 0) {
5505  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5506  return TCL_ERROR;
5507  }
5508 
5509  plflush();
5510  return TCL_OK;
5511 }
5512 
5513 /*--------------------------------------------------------------------------*\
5514  * plsdimapCmd
5515  *
5516  * Processes plsdimap Tcl command.
5517 \*--------------------------------------------------------------------------*/
5518 
5519 static int
5520 plsdimapCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5521 {
5522  PLINT dimxmin;
5523  PLINT dimxmax;
5524  PLINT dimymin;
5525  PLINT dimymax;
5526  PLFLT dimxpmm;
5527  PLFLT dimypmm;
5528 
5529  pl_errcode = 0; errmsg[0] = '\0';
5530 
5531  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5532  Tcl_AppendResult( interp, "command syntax: \"",
5533  "plsdimap dimxmin dimxmax dimymin dimymax dimxpmm dimypmm", "\"",
5534  (char *) NULL);
5535  return TCL_ERROR;
5536  }
5537 
5538  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
5539  (!0 && !0 && (argc != (6 + 1))) ||
5540  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
5541  Tcl_AppendResult( interp, "wrong # args: should be \"",
5542  "plsdimap dimxmin dimxmax dimymin dimymax dimxpmm dimypmm", "\"",
5543  (char *) NULL);
5544  return TCL_ERROR;
5545  }
5546 
5547  dimxmin = atoi(argv[1+0]);
5548  dimxmax = atoi(argv[1+1]);
5549  dimymin = atoi(argv[1+2]);
5550  dimymax = atoi(argv[1+3]);
5551  dimxpmm = atof(argv[1+4]);
5552  dimypmm = atof(argv[1+5]);
5553 
5554  plsdimap ( dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm );
5555 
5556 
5557  if (pl_errcode != 0) {
5558  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5559  return TCL_ERROR;
5560  }
5561 
5562  plflush();
5563  return TCL_OK;
5564 }
5565 
5566 /*--------------------------------------------------------------------------*\
5567  * plsdioriCmd
5568  *
5569  * Processes plsdiori Tcl command.
5570 \*--------------------------------------------------------------------------*/
5571 
5572 static int
5573 plsdioriCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5574 {
5575  PLFLT rot;
5576 
5577  pl_errcode = 0; errmsg[0] = '\0';
5578 
5579  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5580  Tcl_AppendResult( interp, "command syntax: \"",
5581  "plsdiori rot", "\"",
5582  (char *) NULL);
5583  return TCL_ERROR;
5584  }
5585 
5586  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5587  (!0 && !0 && (argc != (1 + 1))) ||
5588  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5589  Tcl_AppendResult( interp, "wrong # args: should be \"",
5590  "plsdiori rot", "\"",
5591  (char *) NULL);
5592  return TCL_ERROR;
5593  }
5594 
5595  rot = atof(argv[1+0]);
5596 
5597  plsdiori ( rot );
5598 
5599 
5600  if (pl_errcode != 0) {
5601  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5602  return TCL_ERROR;
5603  }
5604 
5605  plflush();
5606  return TCL_OK;
5607 }
5608 
5609 /*--------------------------------------------------------------------------*\
5610  * plsdipltCmd
5611  *
5612  * Processes plsdiplt Tcl command.
5613 \*--------------------------------------------------------------------------*/
5614 
5615 static int
5616 plsdipltCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5617 {
5618  PLFLT xmin;
5619  PLFLT ymin;
5620  PLFLT xmax;
5621  PLFLT ymax;
5622 
5623  pl_errcode = 0; errmsg[0] = '\0';
5624 
5625  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5626  Tcl_AppendResult( interp, "command syntax: \"",
5627  "plsdiplt xmin ymin xmax ymax", "\"",
5628  (char *) NULL);
5629  return TCL_ERROR;
5630  }
5631 
5632  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
5633  (!0 && !0 && (argc != (4 + 1))) ||
5634  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
5635  Tcl_AppendResult( interp, "wrong # args: should be \"",
5636  "plsdiplt xmin ymin xmax ymax", "\"",
5637  (char *) NULL);
5638  return TCL_ERROR;
5639  }
5640 
5641  xmin = atof(argv[1+0]);
5642  ymin = atof(argv[1+1]);
5643  xmax = atof(argv[1+2]);
5644  ymax = atof(argv[1+3]);
5645 
5646  plsdiplt ( xmin, ymin, xmax, ymax );
5647 
5648 
5649  if (pl_errcode != 0) {
5650  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5651  return TCL_ERROR;
5652  }
5653 
5654  plflush();
5655  return TCL_OK;
5656 }
5657 
5658 /*--------------------------------------------------------------------------*\
5659  * plsdiplzCmd
5660  *
5661  * Processes plsdiplz Tcl command.
5662 \*--------------------------------------------------------------------------*/
5663 
5664 static int
5665 plsdiplzCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5666 {
5667  PLFLT xmin;
5668  PLFLT ymin;
5669  PLFLT xmax;
5670  PLFLT ymax;
5671 
5672  pl_errcode = 0; errmsg[0] = '\0';
5673 
5674  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5675  Tcl_AppendResult( interp, "command syntax: \"",
5676  "plsdiplz xmin ymin xmax ymax", "\"",
5677  (char *) NULL);
5678  return TCL_ERROR;
5679  }
5680 
5681  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
5682  (!0 && !0 && (argc != (4 + 1))) ||
5683  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
5684  Tcl_AppendResult( interp, "wrong # args: should be \"",
5685  "plsdiplz xmin ymin xmax ymax", "\"",
5686  (char *) NULL);
5687  return TCL_ERROR;
5688  }
5689 
5690  xmin = atof(argv[1+0]);
5691  ymin = atof(argv[1+1]);
5692  xmax = atof(argv[1+2]);
5693  ymax = atof(argv[1+3]);
5694 
5695  plsdiplz ( xmin, ymin, xmax, ymax );
5696 
5697 
5698  if (pl_errcode != 0) {
5699  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5700  return TCL_ERROR;
5701  }
5702 
5703  plflush();
5704  return TCL_OK;
5705 }
5706 
5707 /*--------------------------------------------------------------------------*\
5708  * plseedCmd
5709  *
5710  * Processes plseed Tcl command.
5711 \*--------------------------------------------------------------------------*/
5712 
5713 static int
5714 plseedCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5715 {
5716  unsigned int s;
5717 
5718  pl_errcode = 0; errmsg[0] = '\0';
5719 
5720  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5721  Tcl_AppendResult( interp, "command syntax: \"",
5722  "plseed s", "\"",
5723  (char *) NULL);
5724  return TCL_ERROR;
5725  }
5726 
5727  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5728  (!0 && !0 && (argc != (1 + 1))) ||
5729  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5730  Tcl_AppendResult( interp, "wrong # args: should be \"",
5731  "plseed s", "\"",
5732  (char *) NULL);
5733  return TCL_ERROR;
5734  }
5735 
5736  s = (unsigned int) strtoul(argv[1+0],NULL,10);
5737 
5738  plseed ( s );
5739 
5740 
5741  if (pl_errcode != 0) {
5742  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5743  return TCL_ERROR;
5744  }
5745 
5746  plflush();
5747  return TCL_OK;
5748 }
5749 
5750 /*--------------------------------------------------------------------------*\
5751  * plsescCmd
5752  *
5753  * Processes plsesc Tcl command.
5754 \*--------------------------------------------------------------------------*/
5755 
5756 static int
5757 plsescCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5758 {
5759  char esc;
5760 
5761  pl_errcode = 0; errmsg[0] = '\0';
5762 
5763  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5764  Tcl_AppendResult( interp, "command syntax: \"",
5765  "plsesc esc", "\"",
5766  (char *) NULL);
5767  return TCL_ERROR;
5768  }
5769 
5770  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5771  (!0 && !0 && (argc != (1 + 1))) ||
5772  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5773  Tcl_AppendResult( interp, "wrong # args: should be \"",
5774  "plsesc esc", "\"",
5775  (char *) NULL);
5776  return TCL_ERROR;
5777  }
5778 
5779  esc = argv[1+0][0];
5780 
5781  plsesc ( esc );
5782 
5783 
5784  if (pl_errcode != 0) {
5785  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5786  return TCL_ERROR;
5787  }
5788 
5789  plflush();
5790  return TCL_OK;
5791 }
5792 
5793 /*--------------------------------------------------------------------------*\
5794  * plsfamCmd
5795  *
5796  * Processes plsfam Tcl command.
5797 \*--------------------------------------------------------------------------*/
5798 
5799 static int
5800 plsfamCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5801 {
5802  PLINT fam;
5803  PLINT num;
5804  PLINT bmax;
5805 
5806  pl_errcode = 0; errmsg[0] = '\0';
5807 
5808  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5809  Tcl_AppendResult( interp, "command syntax: \"",
5810  "plsfam fam num bmax", "\"",
5811  (char *) NULL);
5812  return TCL_ERROR;
5813  }
5814 
5815  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
5816  (!0 && !0 && (argc != (3 + 1))) ||
5817  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
5818  Tcl_AppendResult( interp, "wrong # args: should be \"",
5819  "plsfam fam num bmax", "\"",
5820  (char *) NULL);
5821  return TCL_ERROR;
5822  }
5823 
5824  fam = atoi(argv[1+0]);
5825  num = atoi(argv[1+1]);
5826  bmax = atoi(argv[1+2]);
5827 
5828  plsfam ( fam, num, bmax );
5829 
5830 
5831  if (pl_errcode != 0) {
5832  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5833  return TCL_ERROR;
5834  }
5835 
5836  plflush();
5837  return TCL_OK;
5838 }
5839 
5840 /*--------------------------------------------------------------------------*\
5841  * plsfciCmd
5842  *
5843  * Processes plsfci Tcl command.
5844 \*--------------------------------------------------------------------------*/
5845 
5846 static int
5847 plsfciCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5848 {
5849  PLUNICODE fci;
5850 
5851  pl_errcode = 0; errmsg[0] = '\0';
5852 
5853  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5854  Tcl_AppendResult( interp, "command syntax: \"",
5855  "plsfci fci", "\"",
5856  (char *) NULL);
5857  return TCL_ERROR;
5858  }
5859 
5860  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5861  (!0 && !0 && (argc != (1 + 1))) ||
5862  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5863  Tcl_AppendResult( interp, "wrong # args: should be \"",
5864  "plsfci fci", "\"",
5865  (char *) NULL);
5866  return TCL_ERROR;
5867  }
5868 
5869  fci = (PLUNICODE) strtoul(argv[1+0],NULL,10);
5870 
5871  plsfci ( fci );
5872 
5873 
5874  if (pl_errcode != 0) {
5875  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5876  return TCL_ERROR;
5877  }
5878 
5879  plflush();
5880  return TCL_OK;
5881 }
5882 
5883 /*--------------------------------------------------------------------------*\
5884  * plsfnamCmd
5885  *
5886  * Processes plsfnam Tcl command.
5887 \*--------------------------------------------------------------------------*/
5888 
5889 static int
5890 plsfnamCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5891 {
5892  const char *fnam;
5893 
5894  pl_errcode = 0; errmsg[0] = '\0';
5895 
5896  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5897  Tcl_AppendResult( interp, "command syntax: \"",
5898  "plsfnam fnam", "\"",
5899  (char *) NULL);
5900  return TCL_ERROR;
5901  }
5902 
5903  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
5904  (!0 && !0 && (argc != (1 + 1))) ||
5905  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
5906  Tcl_AppendResult( interp, "wrong # args: should be \"",
5907  "plsfnam fnam", "\"",
5908  (char *) NULL);
5909  return TCL_ERROR;
5910  }
5911 
5912  fnam = argv[1+0];
5913 
5914  plsfnam ( fnam );
5915 
5916 
5917  if (pl_errcode != 0) {
5918  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5919  return TCL_ERROR;
5920  }
5921 
5922  plflush();
5923  return TCL_OK;
5924 }
5925 
5926 /*--------------------------------------------------------------------------*\
5927  * plsfontCmd
5928  *
5929  * Processes plsfont Tcl command.
5930 \*--------------------------------------------------------------------------*/
5931 
5932 static int
5933 plsfontCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5934 {
5935  PLINT family;
5936  PLINT style;
5937  PLINT weight;
5938 
5939  pl_errcode = 0; errmsg[0] = '\0';
5940 
5941  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5942  Tcl_AppendResult( interp, "command syntax: \"",
5943  "plsfont family style weight", "\"",
5944  (char *) NULL);
5945  return TCL_ERROR;
5946  }
5947 
5948  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
5949  (!0 && !0 && (argc != (3 + 1))) ||
5950  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
5951  Tcl_AppendResult( interp, "wrong # args: should be \"",
5952  "plsfont family style weight", "\"",
5953  (char *) NULL);
5954  return TCL_ERROR;
5955  }
5956 
5957  family = atoi(argv[1+0]);
5958  style = atoi(argv[1+1]);
5959  weight = atoi(argv[1+2]);
5960 
5961  plsfont ( family, style, weight );
5962 
5963 
5964  if (pl_errcode != 0) {
5965  Tcl_AppendResult(interp, errmsg, (char *) NULL);
5966  return TCL_ERROR;
5967  }
5968 
5969  plflush();
5970  return TCL_OK;
5971 }
5972 
5973 /*--------------------------------------------------------------------------*\
5974  * plsmajCmd
5975  *
5976  * Processes plsmaj Tcl command.
5977 \*--------------------------------------------------------------------------*/
5978 
5979 static int
5980 plsmajCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
5981 {
5982  PLFLT def;
5983  PLFLT scale;
5984 
5985  pl_errcode = 0; errmsg[0] = '\0';
5986 
5987  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
5988  Tcl_AppendResult( interp, "command syntax: \"",
5989  "plsmaj def scale", "\"",
5990  (char *) NULL);
5991  return TCL_ERROR;
5992  }
5993 
5994  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
5995  (!0 && !0 && (argc != (2 + 1))) ||
5996  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
5997  Tcl_AppendResult( interp, "wrong # args: should be \"",
5998  "plsmaj def scale", "\"",
5999  (char *) NULL);
6000  return TCL_ERROR;
6001  }
6002 
6003  def = atof(argv[1+0]);
6004  scale = atof(argv[1+1]);
6005 
6006  plsmaj ( def, scale );
6007 
6008 
6009  if (pl_errcode != 0) {
6010  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6011  return TCL_ERROR;
6012  }
6013 
6014  plflush();
6015  return TCL_OK;
6016 }
6017 
6018 /*--------------------------------------------------------------------------*\
6019  * plsminCmd
6020  *
6021  * Processes plsmin Tcl command.
6022 \*--------------------------------------------------------------------------*/
6023 
6024 static int
6025 plsminCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6026 {
6027  PLFLT def;
6028  PLFLT scale;
6029 
6030  pl_errcode = 0; errmsg[0] = '\0';
6031 
6032  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6033  Tcl_AppendResult( interp, "command syntax: \"",
6034  "plsmin def scale", "\"",
6035  (char *) NULL);
6036  return TCL_ERROR;
6037  }
6038 
6039  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
6040  (!0 && !0 && (argc != (2 + 1))) ||
6041  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6042  Tcl_AppendResult( interp, "wrong # args: should be \"",
6043  "plsmin def scale", "\"",
6044  (char *) NULL);
6045  return TCL_ERROR;
6046  }
6047 
6048  def = atof(argv[1+0]);
6049  scale = atof(argv[1+1]);
6050 
6051  plsmin ( def, scale );
6052 
6053 
6054  if (pl_errcode != 0) {
6055  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6056  return TCL_ERROR;
6057  }
6058 
6059  plflush();
6060  return TCL_OK;
6061 }
6062 
6063 /*--------------------------------------------------------------------------*\
6064  * plsoriCmd
6065  *
6066  * Processes plsori Tcl command.
6067 \*--------------------------------------------------------------------------*/
6068 
6069 static int
6070 plsoriCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6071 {
6072  PLINT ori;
6073 
6074  pl_errcode = 0; errmsg[0] = '\0';
6075 
6076  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6077  Tcl_AppendResult( interp, "command syntax: \"",
6078  "plsori ori", "\"",
6079  (char *) NULL);
6080  return TCL_ERROR;
6081  }
6082 
6083  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
6084  (!0 && !0 && (argc != (1 + 1))) ||
6085  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
6086  Tcl_AppendResult( interp, "wrong # args: should be \"",
6087  "plsori ori", "\"",
6088  (char *) NULL);
6089  return TCL_ERROR;
6090  }
6091 
6092  ori = atoi(argv[1+0]);
6093 
6094  plsori ( ori );
6095 
6096 
6097  if (pl_errcode != 0) {
6098  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6099  return TCL_ERROR;
6100  }
6101 
6102  plflush();
6103  return TCL_OK;
6104 }
6105 
6106 /*--------------------------------------------------------------------------*\
6107  * plspageCmd
6108  *
6109  * Processes plspage Tcl command.
6110 \*--------------------------------------------------------------------------*/
6111 
6112 static int
6113 plspageCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6114 {
6115  PLFLT xp;
6116  PLFLT yp;
6117  PLINT xleng;
6118  PLINT yleng;
6119  PLINT xoff;
6120  PLINT yoff;
6121 
6122  pl_errcode = 0; errmsg[0] = '\0';
6123 
6124  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6125  Tcl_AppendResult( interp, "command syntax: \"",
6126  "plspage xp yp xleng yleng xoff yoff", "\"",
6127  (char *) NULL);
6128  return TCL_ERROR;
6129  }
6130 
6131  if ( (!0 && 0 && (argc < (1 + 6 - 0))) ||
6132  (!0 && !0 && (argc != (6 + 1))) ||
6133  ( 0 && (argc != 1) && (argc != (6 + 1))) ) {
6134  Tcl_AppendResult( interp, "wrong # args: should be \"",
6135  "plspage xp yp xleng yleng xoff yoff", "\"",
6136  (char *) NULL);
6137  return TCL_ERROR;
6138  }
6139 
6140  xp = atof(argv[1+0]);
6141  yp = atof(argv[1+1]);
6142  xleng = atoi(argv[1+2]);
6143  yleng = atoi(argv[1+3]);
6144  xoff = atoi(argv[1+4]);
6145  yoff = atoi(argv[1+5]);
6146 
6147  plspage ( xp, yp, xleng, yleng, xoff, yoff );
6148 
6149 
6150  if (pl_errcode != 0) {
6151  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6152  return TCL_ERROR;
6153  }
6154 
6155  plflush();
6156  return TCL_OK;
6157 }
6158 
6159 /*--------------------------------------------------------------------------*\
6160  * plspal0Cmd
6161  *
6162  * Processes plspal0 Tcl command.
6163 \*--------------------------------------------------------------------------*/
6164 
6165 static int
6166 plspal0Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6167 {
6168  const char *filename;
6169 
6170  pl_errcode = 0; errmsg[0] = '\0';
6171 
6172  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6173  Tcl_AppendResult( interp, "command syntax: \"",
6174  "plspal0 filename", "\"",
6175  (char *) NULL);
6176  return TCL_ERROR;
6177  }
6178 
6179  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
6180  (!0 && !0 && (argc != (1 + 1))) ||
6181  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
6182  Tcl_AppendResult( interp, "wrong # args: should be \"",
6183  "plspal0 filename", "\"",
6184  (char *) NULL);
6185  return TCL_ERROR;
6186  }
6187 
6188  filename = argv[1+0];
6189 
6190  plspal0 ( filename );
6191 
6192 
6193  if (pl_errcode != 0) {
6194  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6195  return TCL_ERROR;
6196  }
6197 
6198  plflush();
6199  return TCL_OK;
6200 }
6201 
6202 /*--------------------------------------------------------------------------*\
6203  * plspal1Cmd
6204  *
6205  * Processes plspal1 Tcl command.
6206 \*--------------------------------------------------------------------------*/
6207 
6208 static int
6209 plspal1Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6210 {
6211  const char *filename;
6212  PLINT interpolate;
6213 
6214  pl_errcode = 0; errmsg[0] = '\0';
6215 
6216  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6217  Tcl_AppendResult( interp, "command syntax: \"",
6218  "plspal1 filename interpolate", "\"",
6219  (char *) NULL);
6220  return TCL_ERROR;
6221  }
6222 
6223  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
6224  (!0 && !0 && (argc != (2 + 1))) ||
6225  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6226  Tcl_AppendResult( interp, "wrong # args: should be \"",
6227  "plspal1 filename interpolate", "\"",
6228  (char *) NULL);
6229  return TCL_ERROR;
6230  }
6231 
6232  filename = argv[1+0];
6233  interpolate = atoi(argv[1+1]);
6234 
6235  plspal1 ( filename, interpolate );
6236 
6237 
6238  if (pl_errcode != 0) {
6239  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6240  return TCL_ERROR;
6241  }
6242 
6243  plflush();
6244  return TCL_OK;
6245 }
6246 
6247 /*--------------------------------------------------------------------------*\
6248  * plspauseCmd
6249  *
6250  * Processes plspause Tcl command.
6251 \*--------------------------------------------------------------------------*/
6252 
6253 static int
6254 plspauseCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6255 {
6256  PLINT paus;
6257 
6258  pl_errcode = 0; errmsg[0] = '\0';
6259 
6260  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6261  Tcl_AppendResult( interp, "command syntax: \"",
6262  "plspause paus", "\"",
6263  (char *) NULL);
6264  return TCL_ERROR;
6265  }
6266 
6267  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
6268  (!0 && !0 && (argc != (1 + 1))) ||
6269  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
6270  Tcl_AppendResult( interp, "wrong # args: should be \"",
6271  "plspause paus", "\"",
6272  (char *) NULL);
6273  return TCL_ERROR;
6274  }
6275 
6276  paus = atoi(argv[1+0]);
6277 
6278  plspause ( paus );
6279 
6280 
6281  if (pl_errcode != 0) {
6282  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6283  return TCL_ERROR;
6284  }
6285 
6286  plflush();
6287  return TCL_OK;
6288 }
6289 
6290 /*--------------------------------------------------------------------------*\
6291  * plsstrmCmd
6292  *
6293  * Processes plsstrm Tcl command.
6294 \*--------------------------------------------------------------------------*/
6295 
6296 static int
6297 plsstrmCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6298 {
6299  PLINT strm;
6300 
6301  pl_errcode = 0; errmsg[0] = '\0';
6302 
6303  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6304  Tcl_AppendResult( interp, "command syntax: \"",
6305  "plsstrm strm", "\"",
6306  (char *) NULL);
6307  return TCL_ERROR;
6308  }
6309 
6310  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
6311  (!0 && !0 && (argc != (1 + 1))) ||
6312  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
6313  Tcl_AppendResult( interp, "wrong # args: should be \"",
6314  "plsstrm strm", "\"",
6315  (char *) NULL);
6316  return TCL_ERROR;
6317  }
6318 
6319  strm = atoi(argv[1+0]);
6320 
6321  plsstrm ( strm );
6322 
6323 
6324  if (pl_errcode != 0) {
6325  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6326  return TCL_ERROR;
6327  }
6328 
6329  plflush();
6330  return TCL_OK;
6331 }
6332 
6333 /*--------------------------------------------------------------------------*\
6334  * plssubCmd
6335  *
6336  * Processes plssub Tcl command.
6337 \*--------------------------------------------------------------------------*/
6338 
6339 static int
6340 plssubCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6341 {
6342  PLINT nx;
6343  PLINT ny;
6344 
6345  pl_errcode = 0; errmsg[0] = '\0';
6346 
6347  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6348  Tcl_AppendResult( interp, "command syntax: \"",
6349  "plssub nx ny", "\"",
6350  (char *) NULL);
6351  return TCL_ERROR;
6352  }
6353 
6354  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
6355  (!0 && !0 && (argc != (2 + 1))) ||
6356  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6357  Tcl_AppendResult( interp, "wrong # args: should be \"",
6358  "plssub nx ny", "\"",
6359  (char *) NULL);
6360  return TCL_ERROR;
6361  }
6362 
6363  nx = atoi(argv[1+0]);
6364  ny = atoi(argv[1+1]);
6365 
6366  plssub ( nx, ny );
6367 
6368 
6369  if (pl_errcode != 0) {
6370  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6371  return TCL_ERROR;
6372  }
6373 
6374  plflush();
6375  return TCL_OK;
6376 }
6377 
6378 /*--------------------------------------------------------------------------*\
6379  * plssymCmd
6380  *
6381  * Processes plssym Tcl command.
6382 \*--------------------------------------------------------------------------*/
6383 
6384 static int
6385 plssymCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6386 {
6387  PLFLT def;
6388  PLFLT scale;
6389 
6390  pl_errcode = 0; errmsg[0] = '\0';
6391 
6392  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6393  Tcl_AppendResult( interp, "command syntax: \"",
6394  "plssym def scale", "\"",
6395  (char *) NULL);
6396  return TCL_ERROR;
6397  }
6398 
6399  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
6400  (!0 && !0 && (argc != (2 + 1))) ||
6401  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6402  Tcl_AppendResult( interp, "wrong # args: should be \"",
6403  "plssym def scale", "\"",
6404  (char *) NULL);
6405  return TCL_ERROR;
6406  }
6407 
6408  def = atof(argv[1+0]);
6409  scale = atof(argv[1+1]);
6410 
6411  plssym ( def, scale );
6412 
6413 
6414  if (pl_errcode != 0) {
6415  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6416  return TCL_ERROR;
6417  }
6418 
6419  plflush();
6420  return TCL_OK;
6421 }
6422 
6423 /*--------------------------------------------------------------------------*\
6424  * plstarCmd
6425  *
6426  * Processes plstar Tcl command.
6427 \*--------------------------------------------------------------------------*/
6428 
6429 static int
6430 plstarCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6431 {
6432  PLINT nx;
6433  PLINT ny;
6434 
6435  pl_errcode = 0; errmsg[0] = '\0';
6436 
6437  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6438  Tcl_AppendResult( interp, "command syntax: \"",
6439  "plstar nx ny", "\"",
6440  (char *) NULL);
6441  return TCL_ERROR;
6442  }
6443 
6444  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
6445  (!0 && !0 && (argc != (2 + 1))) ||
6446  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6447  Tcl_AppendResult( interp, "wrong # args: should be \"",
6448  "plstar nx ny", "\"",
6449  (char *) NULL);
6450  return TCL_ERROR;
6451  }
6452 
6453  nx = atoi(argv[1+0]);
6454  ny = atoi(argv[1+1]);
6455 
6456  plstar ( nx, ny );
6457 
6458 
6459  if (pl_errcode != 0) {
6460  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6461  return TCL_ERROR;
6462  }
6463 
6464  plflush();
6465  return TCL_OK;
6466 }
6467 
6468 /*--------------------------------------------------------------------------*\
6469  * plstartCmd
6470  *
6471  * Processes plstart Tcl command.
6472 \*--------------------------------------------------------------------------*/
6473 
6474 static int
6475 plstartCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6476 {
6477  const char *devname;
6478  PLINT nx;
6479  PLINT ny;
6480 
6481  pl_errcode = 0; errmsg[0] = '\0';
6482 
6483  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6484  Tcl_AppendResult( interp, "command syntax: \"",
6485  "plstart devname nx ny", "\"",
6486  (char *) NULL);
6487  return TCL_ERROR;
6488  }
6489 
6490  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
6491  (!0 && !0 && (argc != (3 + 1))) ||
6492  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
6493  Tcl_AppendResult( interp, "wrong # args: should be \"",
6494  "plstart devname nx ny", "\"",
6495  (char *) NULL);
6496  return TCL_ERROR;
6497  }
6498 
6499  devname = argv[1+0];
6500  nx = atoi(argv[1+1]);
6501  ny = atoi(argv[1+2]);
6502 
6503  plstart ( devname, nx, ny );
6504 
6505 
6506  if (pl_errcode != 0) {
6507  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6508  return TCL_ERROR;
6509  }
6510 
6511  plflush();
6512  return TCL_OK;
6513 }
6514 
6515 /*--------------------------------------------------------------------------*\
6516  * plstringCmd
6517  *
6518  * Processes plstring Tcl command.
6519 \*--------------------------------------------------------------------------*/
6520 
6521 static int
6522 plstringCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6523 {
6524  PLINT n;
6525  PLFLT *x;
6526  tclMatrix *matx;
6527  PLFLT *y;
6528  tclMatrix *maty;
6529  const char *string;
6530 
6531  pl_errcode = 0; errmsg[0] = '\0';
6532 
6533  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6534  Tcl_AppendResult( interp, "command syntax: \"",
6535  "plstring n x y string", "\"",
6536  (char *) NULL);
6537  return TCL_ERROR;
6538  }
6539 
6540  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
6541  (!0 && !0 && (argc != (4 + 1))) ||
6542  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
6543  Tcl_AppendResult( interp, "wrong # args: should be \"",
6544  "plstring n x y string", "\"",
6545  (char *) NULL);
6546  return TCL_ERROR;
6547  }
6548 
6549  n = atoi(argv[1+0]);
6550  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
6551  if (matx == NULL) return TCL_ERROR;
6552  x = matx->fdata;
6553  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
6554  if (maty == NULL) return TCL_ERROR;
6555  y = maty->fdata;
6556  string = argv[1+3];
6557 
6558  plstring ( n, x, y, string );
6559 
6560 
6561  if (pl_errcode != 0) {
6562  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6563  return TCL_ERROR;
6564  }
6565 
6566  plflush();
6567  return TCL_OK;
6568 }
6569 
6570 /*--------------------------------------------------------------------------*\
6571  * plstring3Cmd
6572  *
6573  * Processes plstring3 Tcl command.
6574 \*--------------------------------------------------------------------------*/
6575 
6576 static int
6577 plstring3Cmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6578 {
6579  PLINT n;
6580  PLFLT *x;
6581  tclMatrix *matx;
6582  PLFLT *y;
6583  tclMatrix *maty;
6584  PLFLT *z;
6585  tclMatrix *matz;
6586  const char *string;
6587 
6588  pl_errcode = 0; errmsg[0] = '\0';
6589 
6590  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6591  Tcl_AppendResult( interp, "command syntax: \"",
6592  "plstring3 n x y z string", "\"",
6593  (char *) NULL);
6594  return TCL_ERROR;
6595  }
6596 
6597  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
6598  (!0 && !0 && (argc != (5 + 1))) ||
6599  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
6600  Tcl_AppendResult( interp, "wrong # args: should be \"",
6601  "plstring3 n x y z string", "\"",
6602  (char *) NULL);
6603  return TCL_ERROR;
6604  }
6605 
6606  n = atoi(argv[1+0]);
6607  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
6608  if (matx == NULL) return TCL_ERROR;
6609  x = matx->fdata;
6610  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
6611  if (maty == NULL) return TCL_ERROR;
6612  y = maty->fdata;
6613  matz = Tcl_GetMatrixPtr( interp, argv[1+3] );
6614  if (matz == NULL) return TCL_ERROR;
6615  z = matz->fdata;
6616  string = argv[1+4];
6617 
6618  plstring3 ( n, x, y, z, string );
6619 
6620 
6621  if (pl_errcode != 0) {
6622  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6623  return TCL_ERROR;
6624  }
6625 
6626  plflush();
6627  return TCL_OK;
6628 }
6629 
6630 /*--------------------------------------------------------------------------*\
6631  * plstripaCmd
6632  *
6633  * Processes plstripa Tcl command.
6634 \*--------------------------------------------------------------------------*/
6635 
6636 static int
6637 plstripaCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6638 {
6639  PLINT id;
6640  PLINT pen;
6641  PLFLT x;
6642  PLFLT y;
6643 
6644  pl_errcode = 0; errmsg[0] = '\0';
6645 
6646  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6647  Tcl_AppendResult( interp, "command syntax: \"",
6648  "plstripa id pen x y", "\"",
6649  (char *) NULL);
6650  return TCL_ERROR;
6651  }
6652 
6653  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
6654  (!0 && !0 && (argc != (4 + 1))) ||
6655  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
6656  Tcl_AppendResult( interp, "wrong # args: should be \"",
6657  "plstripa id pen x y", "\"",
6658  (char *) NULL);
6659  return TCL_ERROR;
6660  }
6661 
6662  id = atoi(argv[1+0]);
6663  pen = atoi(argv[1+1]);
6664  x = atof(argv[1+2]);
6665  y = atof(argv[1+3]);
6666 
6667  plstripa ( id, pen, x, y );
6668 
6669 
6670  if (pl_errcode != 0) {
6671  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6672  return TCL_ERROR;
6673  }
6674 
6675  plflush();
6676  return TCL_OK;
6677 }
6678 
6679 /*--------------------------------------------------------------------------*\
6680  * plstripdCmd
6681  *
6682  * Processes plstripd Tcl command.
6683 \*--------------------------------------------------------------------------*/
6684 
6685 static int
6686 plstripdCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6687 {
6688  PLINT id;
6689 
6690  pl_errcode = 0; errmsg[0] = '\0';
6691 
6692  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6693  Tcl_AppendResult( interp, "command syntax: \"",
6694  "plstripd id", "\"",
6695  (char *) NULL);
6696  return TCL_ERROR;
6697  }
6698 
6699  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
6700  (!0 && !0 && (argc != (1 + 1))) ||
6701  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
6702  Tcl_AppendResult( interp, "wrong # args: should be \"",
6703  "plstripd id", "\"",
6704  (char *) NULL);
6705  return TCL_ERROR;
6706  }
6707 
6708  id = atoi(argv[1+0]);
6709 
6710  plstripd ( id );
6711 
6712 
6713  if (pl_errcode != 0) {
6714  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6715  return TCL_ERROR;
6716  }
6717 
6718  plflush();
6719  return TCL_OK;
6720 }
6721 
6722 /*--------------------------------------------------------------------------*\
6723  * plstylCmd
6724  *
6725  * Processes plstyl Tcl command.
6726 \*--------------------------------------------------------------------------*/
6727 
6728 static int
6729 plstylCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6730 {
6731  PLINT nms;
6732  PLINT *mark;
6733  tclMatrix *matmark;
6734  PLINT *space;
6735  tclMatrix *matspace;
6736 
6737  pl_errcode = 0; errmsg[0] = '\0';
6738 
6739  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6740  Tcl_AppendResult( interp, "command syntax: \"",
6741  "plstyl nms mark space", "\"",
6742  (char *) NULL);
6743  return TCL_ERROR;
6744  }
6745 
6746  if ( (!0 && 0 && (argc < (1 + 3 - 0))) ||
6747  (!0 && !0 && (argc != (3 + 1))) ||
6748  ( 0 && (argc != 1) && (argc != (3 + 1))) ) {
6749  Tcl_AppendResult( interp, "wrong # args: should be \"",
6750  "plstyl nms mark space", "\"",
6751  (char *) NULL);
6752  return TCL_ERROR;
6753  }
6754 
6755  nms = atoi(argv[1+0]);
6756  matmark = Tcl_GetMatrixPtr( interp, argv[1+1] );
6757  if (matmark == NULL) return TCL_ERROR;
6758  mark = matmark->idata;
6759  matspace = Tcl_GetMatrixPtr( interp, argv[1+2] );
6760  if (matspace == NULL) return TCL_ERROR;
6761  space = matspace->idata;
6762 
6763  plstyl ( nms, mark, space );
6764 
6765 
6766  if (pl_errcode != 0) {
6767  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6768  return TCL_ERROR;
6769  }
6770 
6771  plflush();
6772  return TCL_OK;
6773 }
6774 
6775 /*--------------------------------------------------------------------------*\
6776  * plsvectCmd
6777  *
6778  * Processes plsvect Tcl command.
6779 \*--------------------------------------------------------------------------*/
6780 
6781 static int
6782 plsvectCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6783 {
6784  PLFLT *arrowx;
6785  tclMatrix *matarrowx;
6786  PLFLT *arrowy;
6787  tclMatrix *matarrowy;
6788  PLINT npts;
6789  PLINT fill;
6790 
6791  pl_errcode = 0; errmsg[0] = '\0';
6792 
6793  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6794  Tcl_AppendResult( interp, "command syntax: \"",
6795  "plsvect arrowx arrowy npts fill", "\"",
6796  (char *) NULL);
6797  return TCL_ERROR;
6798  }
6799 
6800  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
6801  (!0 && !0 && (argc != (4 + 1))) ||
6802  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
6803  Tcl_AppendResult( interp, "wrong # args: should be \"",
6804  "plsvect arrowx arrowy npts fill", "\"",
6805  (char *) NULL);
6806  return TCL_ERROR;
6807  }
6808 
6809  matarrowx = Tcl_GetMatrixPtr( interp, argv[1+0] );
6810  if (matarrowx == NULL) return TCL_ERROR;
6811  arrowx = matarrowx->fdata;
6812  matarrowy = Tcl_GetMatrixPtr( interp, argv[1+1] );
6813  if (matarrowy == NULL) return TCL_ERROR;
6814  arrowy = matarrowy->fdata;
6815  npts = atoi(argv[1+2]);
6816  fill = atoi(argv[1+3]);
6817 
6818  plsvect ( arrowx, arrowy, npts, fill );
6819 
6820 
6821  if (pl_errcode != 0) {
6822  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6823  return TCL_ERROR;
6824  }
6825 
6826  plflush();
6827  return TCL_OK;
6828 }
6829 
6830 /*--------------------------------------------------------------------------*\
6831  * plsvpaCmd
6832  *
6833  * Processes plsvpa Tcl command.
6834 \*--------------------------------------------------------------------------*/
6835 
6836 static int
6837 plsvpaCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6838 {
6839  PLFLT xmin;
6840  PLFLT xmax;
6841  PLFLT ymin;
6842  PLFLT ymax;
6843 
6844  pl_errcode = 0; errmsg[0] = '\0';
6845 
6846  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6847  Tcl_AppendResult( interp, "command syntax: \"",
6848  "plsvpa xmin xmax ymin ymax", "\"",
6849  (char *) NULL);
6850  return TCL_ERROR;
6851  }
6852 
6853  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
6854  (!0 && !0 && (argc != (4 + 1))) ||
6855  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
6856  Tcl_AppendResult( interp, "wrong # args: should be \"",
6857  "plsvpa xmin xmax ymin ymax", "\"",
6858  (char *) NULL);
6859  return TCL_ERROR;
6860  }
6861 
6862  xmin = atof(argv[1+0]);
6863  xmax = atof(argv[1+1]);
6864  ymin = atof(argv[1+2]);
6865  ymax = atof(argv[1+3]);
6866 
6867  plsvpa ( xmin, xmax, ymin, ymax );
6868 
6869 
6870  if (pl_errcode != 0) {
6871  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6872  return TCL_ERROR;
6873  }
6874 
6875  plflush();
6876  return TCL_OK;
6877 }
6878 
6879 /*--------------------------------------------------------------------------*\
6880  * plsxaxCmd
6881  *
6882  * Processes plsxax Tcl command.
6883 \*--------------------------------------------------------------------------*/
6884 
6885 static int
6886 plsxaxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6887 {
6888  PLINT digmax;
6889  PLINT digits;
6890 
6891  pl_errcode = 0; errmsg[0] = '\0';
6892 
6893  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6894  Tcl_AppendResult( interp, "command syntax: \"",
6895  "plsxax digmax digits", "\"",
6896  (char *) NULL);
6897  return TCL_ERROR;
6898  }
6899 
6900  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
6901  (!0 && !0 && (argc != (2 + 1))) ||
6902  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6903  Tcl_AppendResult( interp, "wrong # args: should be \"",
6904  "plsxax digmax digits", "\"",
6905  (char *) NULL);
6906  return TCL_ERROR;
6907  }
6908 
6909  digmax = atoi(argv[1+0]);
6910  digits = atoi(argv[1+1]);
6911 
6912  plsxax ( digmax, digits );
6913 
6914 
6915  if (pl_errcode != 0) {
6916  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6917  return TCL_ERROR;
6918  }
6919 
6920  plflush();
6921  return TCL_OK;
6922 }
6923 
6924 /*--------------------------------------------------------------------------*\
6925  * plsyaxCmd
6926  *
6927  * Processes plsyax Tcl command.
6928 \*--------------------------------------------------------------------------*/
6929 
6930 static int
6931 plsyaxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6932 {
6933  PLINT digmax = 0;
6934  PLINT digits = 0;
6935 
6936  pl_errcode = 0; errmsg[0] = '\0';
6937 
6938  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6939  Tcl_AppendResult( interp, "command syntax: \"",
6940  "plsyax digmax digits", "\"",
6941  (char *) NULL);
6942  return TCL_ERROR;
6943  }
6944 
6945  if ( (!0 && 2 && (argc < (1 + 2 - 2))) ||
6946  (!0 && !2 && (argc != (2 + 1))) ||
6947  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
6948  Tcl_AppendResult( interp, "wrong # args: should be \"",
6949  "plsyax digmax digits", "\"",
6950  (char *) NULL);
6951  return TCL_ERROR;
6952  }
6953 
6954  if (argc > 0+1) {
6955  digmax = atoi(argv[1+0]);
6956  }
6957  if (argc > 1+1) {
6958  digits = atoi(argv[1+1]);
6959  }
6960 
6961  plsyax ( digmax, digits );
6962 
6963 
6964  if (pl_errcode != 0) {
6965  Tcl_AppendResult(interp, errmsg, (char *) NULL);
6966  return TCL_ERROR;
6967  }
6968 
6969  plflush();
6970  return TCL_OK;
6971 }
6972 
6973 /*--------------------------------------------------------------------------*\
6974  * plsymCmd
6975  *
6976  * Processes plsym Tcl command.
6977 \*--------------------------------------------------------------------------*/
6978 
6979 static int
6980 plsymCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
6981 {
6982  PLINT n;
6983  PLFLT *x;
6984  tclMatrix *matx;
6985  PLFLT *y;
6986  tclMatrix *maty;
6987  PLINT code;
6988 
6989  pl_errcode = 0; errmsg[0] = '\0';
6990 
6991  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
6992  Tcl_AppendResult( interp, "command syntax: \"",
6993  "plsym n x y code", "\"",
6994  (char *) NULL);
6995  return TCL_ERROR;
6996  }
6997 
6998  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
6999  (!0 && !0 && (argc != (4 + 1))) ||
7000  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
7001  Tcl_AppendResult( interp, "wrong # args: should be \"",
7002  "plsym n x y code", "\"",
7003  (char *) NULL);
7004  return TCL_ERROR;
7005  }
7006 
7007  n = atoi(argv[1+0]);
7008  matx = Tcl_GetMatrixPtr( interp, argv[1+1] );
7009  if (matx == NULL) return TCL_ERROR;
7010  x = matx->fdata;
7011  maty = Tcl_GetMatrixPtr( interp, argv[1+2] );
7012  if (maty == NULL) return TCL_ERROR;
7013  y = maty->fdata;
7014  code = atoi(argv[1+3]);
7015 
7016  plsym ( n, x, y, code );
7017 
7018 
7019  if (pl_errcode != 0) {
7020  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7021  return TCL_ERROR;
7022  }
7023 
7024  plflush();
7025  return TCL_OK;
7026 }
7027 
7028 /*--------------------------------------------------------------------------*\
7029  * plszaxCmd
7030  *
7031  * Processes plszax Tcl command.
7032 \*--------------------------------------------------------------------------*/
7033 
7034 static int
7035 plszaxCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7036 {
7037  PLINT digmax;
7038  PLINT digits;
7039 
7040  pl_errcode = 0; errmsg[0] = '\0';
7041 
7042  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7043  Tcl_AppendResult( interp, "command syntax: \"",
7044  "plszax digmax digits", "\"",
7045  (char *) NULL);
7046  return TCL_ERROR;
7047  }
7048 
7049  if ( (!0 && 0 && (argc < (1 + 2 - 0))) ||
7050  (!0 && !0 && (argc != (2 + 1))) ||
7051  ( 0 && (argc != 1) && (argc != (2 + 1))) ) {
7052  Tcl_AppendResult( interp, "wrong # args: should be \"",
7053  "plszax digmax digits", "\"",
7054  (char *) NULL);
7055  return TCL_ERROR;
7056  }
7057 
7058  digmax = atoi(argv[1+0]);
7059  digits = atoi(argv[1+1]);
7060 
7061  plszax ( digmax, digits );
7062 
7063 
7064  if (pl_errcode != 0) {
7065  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7066  return TCL_ERROR;
7067  }
7068 
7069  plflush();
7070  return TCL_OK;
7071 }
7072 
7073 /*--------------------------------------------------------------------------*\
7074  * pltextCmd
7075  *
7076  * Processes pltext Tcl command.
7077 \*--------------------------------------------------------------------------*/
7078 
7079 static int
7080 pltextCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7081 {
7082 
7083  pl_errcode = 0; errmsg[0] = '\0';
7084 
7085  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7086  Tcl_AppendResult( interp, "command syntax: \"",
7087  "pltext ", "\"",
7088  (char *) NULL);
7089  return TCL_ERROR;
7090  }
7091 
7092  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
7093  (!0 && !0 && (argc != (0 + 1))) ||
7094  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
7095  Tcl_AppendResult( interp, "wrong # args: should be \"",
7096  "pltext ", "\"",
7097  (char *) NULL);
7098  return TCL_ERROR;
7099  }
7100 
7101 
7102  pltext ( );
7103 
7104 
7105  if (pl_errcode != 0) {
7106  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7107  return TCL_ERROR;
7108  }
7109 
7110  plflush();
7111  return TCL_OK;
7112 }
7113 
7114 /*--------------------------------------------------------------------------*\
7115  * pltimefmtCmd
7116  *
7117  * Processes pltimefmt Tcl command.
7118 \*--------------------------------------------------------------------------*/
7119 
7120 static int
7121 pltimefmtCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7122 {
7123  const char *fmt;
7124 
7125  pl_errcode = 0; errmsg[0] = '\0';
7126 
7127  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7128  Tcl_AppendResult( interp, "command syntax: \"",
7129  "pltimefmt fmt", "\"",
7130  (char *) NULL);
7131  return TCL_ERROR;
7132  }
7133 
7134  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
7135  (!0 && !0 && (argc != (1 + 1))) ||
7136  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
7137  Tcl_AppendResult( interp, "wrong # args: should be \"",
7138  "pltimefmt fmt", "\"",
7139  (char *) NULL);
7140  return TCL_ERROR;
7141  }
7142 
7143  fmt = argv[1+0];
7144 
7145  pltimefmt ( fmt );
7146 
7147 
7148  if (pl_errcode != 0) {
7149  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7150  return TCL_ERROR;
7151  }
7152 
7153  plflush();
7154  return TCL_OK;
7155 }
7156 
7157 /*--------------------------------------------------------------------------*\
7158  * plvaspCmd
7159  *
7160  * Processes plvasp Tcl command.
7161 \*--------------------------------------------------------------------------*/
7162 
7163 static int
7164 plvaspCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7165 {
7166  PLFLT aspect;
7167 
7168  pl_errcode = 0; errmsg[0] = '\0';
7169 
7170  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7171  Tcl_AppendResult( interp, "command syntax: \"",
7172  "plvasp aspect", "\"",
7173  (char *) NULL);
7174  return TCL_ERROR;
7175  }
7176 
7177  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
7178  (!0 && !0 && (argc != (1 + 1))) ||
7179  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
7180  Tcl_AppendResult( interp, "wrong # args: should be \"",
7181  "plvasp aspect", "\"",
7182  (char *) NULL);
7183  return TCL_ERROR;
7184  }
7185 
7186  aspect = atof(argv[1+0]);
7187 
7188  plvasp ( aspect );
7189 
7190 
7191  if (pl_errcode != 0) {
7192  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7193  return TCL_ERROR;
7194  }
7195 
7196  plflush();
7197  return TCL_OK;
7198 }
7199 
7200 /*--------------------------------------------------------------------------*\
7201  * plvpasCmd
7202  *
7203  * Processes plvpas Tcl command.
7204 \*--------------------------------------------------------------------------*/
7205 
7206 static int
7207 plvpasCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7208 {
7209  PLFLT xmin;
7210  PLFLT xmax;
7211  PLFLT ymin;
7212  PLFLT ymax;
7213  PLFLT aspect;
7214 
7215  pl_errcode = 0; errmsg[0] = '\0';
7216 
7217  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7218  Tcl_AppendResult( interp, "command syntax: \"",
7219  "plvpas xmin xmax ymin ymax aspect", "\"",
7220  (char *) NULL);
7221  return TCL_ERROR;
7222  }
7223 
7224  if ( (!0 && 0 && (argc < (1 + 5 - 0))) ||
7225  (!0 && !0 && (argc != (5 + 1))) ||
7226  ( 0 && (argc != 1) && (argc != (5 + 1))) ) {
7227  Tcl_AppendResult( interp, "wrong # args: should be \"",
7228  "plvpas xmin xmax ymin ymax aspect", "\"",
7229  (char *) NULL);
7230  return TCL_ERROR;
7231  }
7232 
7233  xmin = atof(argv[1+0]);
7234  xmax = atof(argv[1+1]);
7235  ymin = atof(argv[1+2]);
7236  ymax = atof(argv[1+3]);
7237  aspect = atof(argv[1+4]);
7238 
7239  plvpas ( xmin, xmax, ymin, ymax, aspect );
7240 
7241 
7242  if (pl_errcode != 0) {
7243  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7244  return TCL_ERROR;
7245  }
7246 
7247  plflush();
7248  return TCL_OK;
7249 }
7250 
7251 /*--------------------------------------------------------------------------*\
7252  * plvporCmd
7253  *
7254  * Processes plvpor Tcl command.
7255 \*--------------------------------------------------------------------------*/
7256 
7257 static int
7258 plvporCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7259 {
7260  PLFLT xmin;
7261  PLFLT xmax;
7262  PLFLT ymin;
7263  PLFLT ymax;
7264 
7265  pl_errcode = 0; errmsg[0] = '\0';
7266 
7267  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7268  Tcl_AppendResult( interp, "command syntax: \"",
7269  "plvpor xmin xmax ymin ymax", "\"",
7270  (char *) NULL);
7271  return TCL_ERROR;
7272  }
7273 
7274  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
7275  (!0 && !0 && (argc != (4 + 1))) ||
7276  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
7277  Tcl_AppendResult( interp, "wrong # args: should be \"",
7278  "plvpor xmin xmax ymin ymax", "\"",
7279  (char *) NULL);
7280  return TCL_ERROR;
7281  }
7282 
7283  xmin = atof(argv[1+0]);
7284  xmax = atof(argv[1+1]);
7285  ymin = atof(argv[1+2]);
7286  ymax = atof(argv[1+3]);
7287 
7288  plvpor ( xmin, xmax, ymin, ymax );
7289 
7290 
7291  if (pl_errcode != 0) {
7292  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7293  return TCL_ERROR;
7294  }
7295 
7296  plflush();
7297  return TCL_OK;
7298 }
7299 
7300 /*--------------------------------------------------------------------------*\
7301  * plvstaCmd
7302  *
7303  * Processes plvsta Tcl command.
7304 \*--------------------------------------------------------------------------*/
7305 
7306 static int
7307 plvstaCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7308 {
7309 
7310  pl_errcode = 0; errmsg[0] = '\0';
7311 
7312  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7313  Tcl_AppendResult( interp, "command syntax: \"",
7314  "plvsta ", "\"",
7315  (char *) NULL);
7316  return TCL_ERROR;
7317  }
7318 
7319  if ( (!0 && 0 && (argc < (1 + 0 - 0))) ||
7320  (!0 && !0 && (argc != (0 + 1))) ||
7321  ( 0 && (argc != 1) && (argc != (0 + 1))) ) {
7322  Tcl_AppendResult( interp, "wrong # args: should be \"",
7323  "plvsta ", "\"",
7324  (char *) NULL);
7325  return TCL_ERROR;
7326  }
7327 
7328 
7329  plvsta ( );
7330 
7331 
7332  if (pl_errcode != 0) {
7333  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7334  return TCL_ERROR;
7335  }
7336 
7337  plflush();
7338  return TCL_OK;
7339 }
7340 
7341 /*--------------------------------------------------------------------------*\
7342  * plw3dCmd
7343  *
7344  * Processes plw3d Tcl command.
7345 \*--------------------------------------------------------------------------*/
7346 
7347 static int
7348 plw3dCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7349 {
7350  PLFLT basex;
7351  PLFLT basey;
7352  PLFLT height;
7353  PLFLT xmin0;
7354  PLFLT xmax0;
7355  PLFLT ymin0;
7356  PLFLT ymax0;
7357  PLFLT zmin0;
7358  PLFLT zmax0;
7359  PLFLT alt;
7360  PLFLT az;
7361 
7362  pl_errcode = 0; errmsg[0] = '\0';
7363 
7364  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7365  Tcl_AppendResult( interp, "command syntax: \"",
7366  "plw3d basex basey height xmin0 xmax0 ymin0 ymax0 zmin0 zmax0 alt az", "\"",
7367  (char *) NULL);
7368  return TCL_ERROR;
7369  }
7370 
7371  if ( (!0 && 0 && (argc < (1 + 11 - 0))) ||
7372  (!0 && !0 && (argc != (11 + 1))) ||
7373  ( 0 && (argc != 1) && (argc != (11 + 1))) ) {
7374  Tcl_AppendResult( interp, "wrong # args: should be \"",
7375  "plw3d basex basey height xmin0 xmax0 ymin0 ymax0 zmin0 zmax0 alt az", "\"",
7376  (char *) NULL);
7377  return TCL_ERROR;
7378  }
7379 
7380  basex = atof(argv[1+0]);
7381  basey = atof(argv[1+1]);
7382  height = atof(argv[1+2]);
7383  xmin0 = atof(argv[1+3]);
7384  xmax0 = atof(argv[1+4]);
7385  ymin0 = atof(argv[1+5]);
7386  ymax0 = atof(argv[1+6]);
7387  zmin0 = atof(argv[1+7]);
7388  zmax0 = atof(argv[1+8]);
7389  alt = atof(argv[1+9]);
7390  az = atof(argv[1+10]);
7391 
7392  plw3d ( basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0, alt, az );
7393 
7394 
7395  if (pl_errcode != 0) {
7396  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7397  return TCL_ERROR;
7398  }
7399 
7400  plflush();
7401  return TCL_OK;
7402 }
7403 
7404 /*--------------------------------------------------------------------------*\
7405  * plwidthCmd
7406  *
7407  * Processes plwidth Tcl command.
7408 \*--------------------------------------------------------------------------*/
7409 
7410 static int
7411 plwidthCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7412 {
7413  PLFLT width;
7414 
7415  pl_errcode = 0; errmsg[0] = '\0';
7416 
7417  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7418  Tcl_AppendResult( interp, "command syntax: \"",
7419  "plwidth width", "\"",
7420  (char *) NULL);
7421  return TCL_ERROR;
7422  }
7423 
7424  if ( (!0 && 0 && (argc < (1 + 1 - 0))) ||
7425  (!0 && !0 && (argc != (1 + 1))) ||
7426  ( 0 && (argc != 1) && (argc != (1 + 1))) ) {
7427  Tcl_AppendResult( interp, "wrong # args: should be \"",
7428  "plwidth width", "\"",
7429  (char *) NULL);
7430  return TCL_ERROR;
7431  }
7432 
7433  width = atof(argv[1+0]);
7434 
7435  plwidth ( width );
7436 
7437 
7438  if (pl_errcode != 0) {
7439  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7440  return TCL_ERROR;
7441  }
7442 
7443  plflush();
7444  return TCL_OK;
7445 }
7446 
7447 /*--------------------------------------------------------------------------*\
7448  * plwindCmd
7449  *
7450  * Processes plwind Tcl command.
7451 \*--------------------------------------------------------------------------*/
7452 
7453 static int
7454 plwindCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7455 {
7456  PLFLT xmin;
7457  PLFLT xmax;
7458  PLFLT ymin;
7459  PLFLT ymax;
7460 
7461  pl_errcode = 0; errmsg[0] = '\0';
7462 
7463  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7464  Tcl_AppendResult( interp, "command syntax: \"",
7465  "plwind xmin xmax ymin ymax", "\"",
7466  (char *) NULL);
7467  return TCL_ERROR;
7468  }
7469 
7470  if ( (!0 && 0 && (argc < (1 + 4 - 0))) ||
7471  (!0 && !0 && (argc != (4 + 1))) ||
7472  ( 0 && (argc != 1) && (argc != (4 + 1))) ) {
7473  Tcl_AppendResult( interp, "wrong # args: should be \"",
7474  "plwind xmin xmax ymin ymax", "\"",
7475  (char *) NULL);
7476  return TCL_ERROR;
7477  }
7478 
7479  xmin = atof(argv[1+0]);
7480  xmax = atof(argv[1+1]);
7481  ymin = atof(argv[1+2]);
7482  ymax = atof(argv[1+3]);
7483 
7484  plwind ( xmin, xmax, ymin, ymax );
7485 
7486 
7487  if (pl_errcode != 0) {
7488  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7489  return TCL_ERROR;
7490  }
7491 
7492  plflush();
7493  return TCL_OK;
7494 }
7495 
7496 /*--------------------------------------------------------------------------*\
7497  * plxormodCmd
7498  *
7499  * Processes plxormod Tcl command.
7500 \*--------------------------------------------------------------------------*/
7501 
7502 static int
7503 plxormodCmd( ClientData PL_UNUSED( clientData ), Tcl_Interp *interp, int argc, const char *argv[] )
7504 {
7505  PLINT mod;
7506  PLINT st;
7507 
7508  pl_errcode = 0; errmsg[0] = '\0';
7509 
7510  if ( (argc == 2) && (strlen(argv[1])>0) && (strncmp(argv[1],"-help",strlen(argv[1])) == 0) ) {
7511  Tcl_AppendResult( interp, "command syntax: \"",
7512  "plxormod ?mod st?", "\"",
7513  (char *) NULL);
7514  return TCL_ERROR;
7515  }
7516 
7517  if ( (!1 && 0 && (argc < (1 + 2 - 0))) ||
7518  (!1 && !0 && (argc != (2 + 1))) ||
7519  ( 1 && (argc != 1) && (argc != (2 + 1))) ) {
7520  Tcl_AppendResult( interp, "wrong # args: should be \"",
7521  "plxormod ?mod st?", "\"",
7522  (char *) NULL);
7523  return TCL_ERROR;
7524  }
7525 
7526  mod = atoi(argv[1+0]);
7527 /* st is for output. */
7528 
7529  plxormod ( mod, &st );
7530 
7531  if (argc == 1)
7532  Tcl_AppendResult( interp, " ", (char *) NULL );
7533  sprintf( buf, "%d", st );
7534  if (argc > 1)
7535  Tcl_SetVar( interp, argv[1+1], buf, 0 );
7536  else
7537  Tcl_AppendResult( interp, buf, (char *) NULL );
7538 
7539  if (pl_errcode != 0) {
7540  Tcl_AppendResult(interp, errmsg, (char *) NULL);
7541  return TCL_ERROR;
7542  }
7543 
7544  plflush();
7545  return TCL_OK;
7546 }
7547 
static int pllstyCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3838
static int plscmap1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4792
subroutine plbox(xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:148
static int plmkstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3881
#define plsfam
Definition: plplot.h:709
#define plw3d
Definition: plplot.h:754
static int plgfamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2458
static PLINT text
Definition: gcw.c:97
static char ** argv
Definition: qt.cpp:40
#define plgxax
Definition: plplot.h:642
void plgesc(char *p_esc)
Definition: plcore.c:3750
#define plsstrm
Definition: plplot.h:727
static int pllightsourceCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3680
static int plerryCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1376
static int plptex3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4405
#define plspage
Definition: plplot.h:723
#define plvpor
Definition: plplot.h:752
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT nx
static int plhlsrgbCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3469
#define plerry
Definition: plplot.h:610
#define plsyax
Definition: plplot.h:744
static int plsdidevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5471
#define plschr
Definition: plplot.h:683
subroutine plmtex3(side, disp, pos, xjust, text)
Definition: sfstubs.f90:722
static int plgfnamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2572
int min(int a, int b)
static int plgcolbgaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2042
subroutine plsfnam(fnam)
Definition: sfstubs.f90:92
static int plvaspCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7164
void pldid2pc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1573
#define plscompression
Definition: plplot.h:699
static int plscompressionCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5385
#define plarc
Definition: plplot.h:588
PLUINT PLUNICODE
Definition: plplot.h:195
subroutine plstring3(x, y, z, string)
Definition: sfstubs.f90:327
static int plgstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2997
static int plcpstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:832
static int plsdimapCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5520
static int plscmap0nCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4749
static int plgzaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3356
#define pllsty
Definition: plplot.h:658
tclMatrix * Tcl_GetMatrixPtr(Tcl_Interp *interp, const char *matName)
Definition: tclMatrix.c:370
static int plspal1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6209
#define plsmin
Definition: plplot.h:720
#define plwind
Definition: plplot.h:757
#define plclear
Definition: plplot.h:596
#define plfill
Definition: plplot.h:612
#define plconfigtime
Definition: plplot.h:600
static int argc
Definition: qt.cpp:39
static int plvporCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7258
#define plbtime
Definition: plplot.h:594
subroutine plmtex(side, disp, pos, xjust, text)
Definition: sfstubs.f90:705
static int plaxesCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:204
#define pl_setcontlabelparam
Definition: plplot.h:586
static int plscmap1aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4850
static int plreplotCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4468
#define plscolbg
Definition: plplot.h:696
static int plscmap0aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4686
#define plfont
Definition: plplot.h:615
#define plstyl
Definition: plplot.h:738
static int plschrCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4583
#define plpoly3
Definition: plplot.h:673
subroutine plstring(x, y, string)
Definition: sfstubs.f90:309
#define plfontld
Definition: plplot.h:616
subroutine plgdev(dnam)
Definition: sfstubs.f90:80
static int plstringCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6522
#define plscolbga
Definition: plplot.h:697
#define plbin
Definition: plplot.h:590
#define plsdiori
Definition: plplot.h:703
static int plgverCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3045
#define plsym
Definition: plplot.h:745
static int plsminCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6025
#define plscmap1
Definition: plplot.h:687
#define plinit
Definition: plplot.h:650
void PLFLT PLINT PLINT PLFLT x
static int plgcmap1_rangeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1770
tuple xmin
Definition: Plframe.py:907
static int plgfontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2619
#define plctime
Definition: plplot.h:603
#define plscmap1n
Definition: plplot.h:691
void pldip2dc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1619
#define plbop
Definition: plplot.h:591
static int plvpasCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7207
static int plgradientCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2867
static int plsescCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5757
#define plsdiplt
Definition: plplot.h:704
static int plctimeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:877
#define plsvect
Definition: plplot.h:741
#define plscmap1a
Definition: plplot.h:688
#define plssub
Definition: plplot.h:728
static int plgpageCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2733
static int plpoly3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4199
#define plgcompression
Definition: plplot.h:622
#define plszax
Definition: plplot.h:746
#define plvsta
Definition: plplot.h:753
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT const PLINT const PLFLT * a
static int plgescCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2410
tuple ymin
Definition: Plframe.py:908
#define plgpage
Definition: plplot.h:633
#define plsori
Definition: plplot.h:722
static int plgxaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3242
static int plline3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3780
static int plscol0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5146
#define plgdiplt
Definition: plplot.h:626
#define plscmap0a
Definition: plplot.h:685
#define plfamadv
Definition: plplot.h:611
static int plcol1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:726
subroutine plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)
Definition: sfstubs.f90:166
static int plstarCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6430
#define plend
Definition: plplot.h:604
static int plscmap1laCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4983
static int plglevelCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2685
static int plbinCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:261
#define plgfont
Definition: plplot.h:631
static int plprecCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4264
#define plend1
Definition: plplot.h:605
int PLINT
Definition: plplot.h:175
#define plenv0
Definition: plplot.h:607
#define plgdiori
Definition: plplot.h:625
static int plgcol0aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1897
#define plssym
Definition: plplot.h:729
#define pljoin
Definition: plplot.h:651
#define plgzax
Definition: plplot.h:644
static int plendCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1089
static int plpoin3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4139
#define plgfam
Definition: plplot.h:628
static int plssymCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6385
#define plgdidev
Definition: plplot.h:624
static int plxormodCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7503
#define plstar
Definition: plplot.h:730
static int plgdidevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2212
static int plenvCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1171
static int plsdipltCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5616
#define plcpstrm
Definition: plplot.h:602
#define plcalc_world
Definition: plplot.h:595
#define plhist
Definition: plplot.h:645
static int pladvCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:102
static int plgspaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2922
static int plend1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1130
Mat_float * fdata
Definition: tclMatrix.h:73
static int plenv0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1224
static int plpoinCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4084
#define plgchr
Definition: plplot.h:617
#define plsdidev
Definition: plplot.h:701
static int plgcompressionCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2117
static int plscmap1lCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4913
#define plfill3
Definition: plplot.h:613
subroutine plgver(ver)
Definition: sfstubs.f90:117
void PLFLT PLINT PLINT PLFLT PLFLT y
subroutine plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:130
static int plmtex3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3980
#define plseed
Definition: plplot.h:706
static int plfillCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1475
static int plsdioriCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5573
static int plbox3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:410
static int plfontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1627
static PLINT pl_errcode
Definition: tclAPI.c:135
static int plscmap1nCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5058
#define plscmap1la
Definition: plplot.h:690
#define plsxax
Definition: plplot.h:743
subroutine plspal0(filename)
Definition: sfstubs.f90:676
#define pleop
Definition: plplot.h:608
static int plrgbhlsCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4509
static int plgyaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3299
#define plhlsrgb
Definition: plplot.h:647
static int plvstaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7307
#define plsmaj
Definition: plplot.h:717
static int plbtimeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:475
static int pldip2dcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1014
static int plscolorCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5342
static int plsvpaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6837
static int plflushCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1586
#define plcol1
Definition: plplot.h:598
Mat_int * idata
Definition: tclMatrix.h:74
#define pllightsource
Definition: plplot.h:654
pl_setcontlabelformat
Definition: tclgen_s.h:1
static int plboxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:357
static int plpatCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4031
static int plspauseCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6254
#define pltext
Definition: plplot.h:747
#define plwidth
Definition: plplot.h:756
static int plsfontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5933
static int plgvpdCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3092
static int plgdipltCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2335
#define plscol0a
Definition: plplot.h:695
static int plclearCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:642
static int plbopCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:316
#define plsdiplz
Definition: plplot.h:705
static char buf[200]
Definition: tclAPI.c:819
static int plstring3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6577
static int plpstyCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4309
#define plspause
Definition: plplot.h:726
static int plgvpwCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3167
subroutine plptex(x, y, dx, dy, xjust, text)
Definition: sfstubs.f90:739
static int plsstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6297
tuple xmax
Definition: Plframe.py:909
#define plline3
Definition: plplot.h:657
#define plstripd
Definition: plplot.h:737
#define plgfci
Definition: plplot.h:629
#define plgspa
Definition: plplot.h:637
#define plgcolbg
Definition: plplot.h:620
static int plscol0aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5195
#define plstripa
Definition: plplot.h:735
static int plwidthCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7411
subroutine plgfnam(fnam)
Definition: sfstubs.f90:105
static int plsymCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6980
#define plvpas
Definition: plplot.h:751
static int plscolbgaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5293
static int plarcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:147
#define plsfont
Definition: plplot.h:712
static int plstripdCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6686
static int plscolbgCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5246
subroutine pllab(xlab, ylab, title)
Definition: sfstubs.f90:658
#define plpsty
Definition: plplot.h:675
static int plseedCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5714
static int plsoriCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6070
static int pl_setcontlabelparamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:53
#define plgvpd
Definition: plplot.h:640
#define plpoin
Definition: plplot.h:671
#define plgvpw
Definition: plplot.h:641
static int plw3dCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7348
subroutine plsdev(dnam)
Definition: sfstubs.f90:67
static int plhistCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3413
static int plsmajCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5980
static int plsdiplzCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5665
static int plstripaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6637
static int plgfciCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2524
static int plspageCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6113
#define plmkstrm
Definition: plplot.h:663
#define PL_UNUSED(x)
Definition: plplot.h:130
static int plstartCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6475
float PLFLT
Definition: plplot.h:159
#define plscol0
Definition: plplot.h:694
#define plxormod
Definition: plplot.h:758
static int plsdevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5428
#define plflush
Definition: plplot.h:614
#define plerrx
Definition: plplot.h:609
#define plgcol0a
Definition: plplot.h:619
static int pllineCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3727
static int plsxaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6886
#define plgcolbga
Definition: plplot.h:621
#define plgyax
Definition: plplot.h:643
#define plsesc
Definition: plplot.h:707
static int plcol0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:683
#define plenv
Definition: plplot.h:606
static int plerrxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1318
static int plgcol0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1827
subroutine plspal1(filename, interpolate)
Definition: sfstubs.f90:690
#define plgcmap1_range
Definition: plplot.h:693
#define plcol0
Definition: plplot.h:597
static int plstylCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6729
static int plgchrCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1713
static int plssubCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6340
static int plwindCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7454
tuple ymax
Definition: Plframe.py:910
static int pldid2pcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:939
subroutine plstart(devname, nx, ny)
Definition: sfstubs.f90:769
static int plfontldCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1670
static int plfamadvCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1434
static int plsyaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6931
#define plglevel
Definition: plplot.h:632
#define plpoin3
Definition: plplot.h:672
static int plgraCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2826
static int pllabCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3633
#define plscmap0n
Definition: plplot.h:686
subroutine plptex3(x, y, z, dx, dy, dz, sx, sy, sz, xjust, text)
Definition: sfstubs.f90:754
#define plscolor
Definition: plplot.h:698
static int plscmap0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4628
#define plsvpa
Definition: plplot.h:742
static int pleopCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1277
static int plgcolbgCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1976
#define plpat
Definition: plplot.h:670
static int plsfamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5800
#define plscmap1_range
Definition: plplot.h:692
static int plszaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7035
#define plgcol0
Definition: plplot.h:618
#define plreplot
Definition: plplot.h:679
static int pltimefmtCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7121
static Tcl_Interp * interp
Definition: tkMain.c:116
static char errmsg[160]
Definition: tclAPI.c:136
#define plscmap1l
Definition: plplot.h:689
#define plprec
Definition: plplot.h:674
static int plinitCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3543
#define plline
Definition: plplot.h:655
static int plsfciCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5847
#define plgradient
Definition: plplot.h:635
dx
if { $zoomopts($this,1) == 0 } then {
Definition: Plframe.py:613
static int pljoinCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3584
#define pladv
Definition: plplot.h:587
#define plvasp
Definition: plplot.h:749
static int plconfigtimeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:769
static int plspal0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6166
#define plscmap0
Definition: plplot.h:684
static int pl_setcontlabelformatCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:8
#define plgstrm
Definition: plplot.h:638
static PLINT sigprec
Definition: plcont.c:97
static int plsvectCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:6782
#define plsfci
Definition: plplot.h:710
static int plptexCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:4352
subroutine pltimefmt(fmt)
Definition: sfstubs.f90:784
static int plfill3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:1528
static int plgdevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2165
#define plrgbhls
Definition: plplot.h:682
#define plgra
Definition: plplot.h:634
#define plsdimap
Definition: plplot.h:702
static int plsfnamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5890
static int plgdioriCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:2287
static int plmtexCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:3929
static int pltextCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:7080
static int plscmap1_rangeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:5101
static int plcalc_worldCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
Definition: tclgen.c:570