PLplot  5.10.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plstream.h
Go to the documentation of this file.
1 //----------------------------------*-C++-*----------------------------------//
2 // $Id: plstream.h 12885 2013-12-19 11:43:30Z andrewross $
3 // Geoffrey Furnish
4 // Sep 21 1994
5 //
6 // Copyright (C) 2004,2005 Andrew Ross
7 // Copyright (C) 2004 Alan W. Irwin
8 //
9 // This file is part of PLplot.
10 //
11 // PLplot is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU Library General Public License as published
13 // by the Free Software Foundation; either version 2 of the License, or
14 // (at your option) any later version.
15 //
16 // PLplot is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU Library General Public License for more details.
20 //
21 // You should have received a copy of the GNU Library General Public License
22 // along with PLplot; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 
25 //--------------------------------------------------------------------------
26 // @> Header file plstream.
27 //--------------------------------------------------------------------------
28 
29 #ifndef __plstream_h__
30 #define __plstream_h__
31 
32 #include "plplot.h"
33 
34 class PLS {
35 public:
37 };
38 
39 enum PLcolor { Black = 0, Red, Yellow, Green,
43 
44 // A class for assisting in generalizing the data prescription
45 // interface to the contouring routines.
46 
48  int _nx, _ny;
49 public:
50  Contourable_Data( int nx, int ny ) : _nx( nx ), _ny( ny ) {}
51  virtual void elements( int& nx, int& ny ) const { nx = _nx; ny = _ny; }
52  virtual PLFLT operator()( int i, int j ) const = 0;
53  virtual ~Contourable_Data() {};
54 };
55 
57 
59 public:
60  virtual void xform( PLFLT ox, PLFLT oy, PLFLT& nx, PLFLT& ny ) const = 0;
61  virtual ~Coord_Xformer() {};
62 };
63 
65 
66 class Coord_2d {
67 public:
68  virtual PLFLT operator()( int ix, int iy ) const = 0;
69  virtual void elements( int& _nx, int& _ny ) = 0;
70  virtual void min_max( PLFLT& _min, PLFLT& _max ) = 0;
71  virtual ~Coord_2d() {};
72 };
73 
77 public:
78  cxx_pltr2( Coord_2d & cx, Coord_2d & cy );
79  void xform( PLFLT x, PLFLT y, PLFLT& tx, PLFLT& ty ) const;
80 };
81 
82 //--------------------------------------------------------------------------
83 // class plstream - C++ class for encapsulating PLplot streams
84 
85 // Cool stuff.
86 //--------------------------------------------------------------------------
87 
90 
92 
93 private:
94  // These have to be disabled till we implement reference counting.
95 
96  plstream( const plstream & );
97  plstream& operator=( const plstream& );
98 
99 protected:
100  virtual void set_stream( void ) { ::c_plsstrm( stream ); }
101 
102 public:
103  plstream( void );
104  plstream( plstream * pls );
105  plstream( PLS::stream_id sid, PLINT strm = 0 );
106  plstream( PLINT _stream ) : stream( _stream ) {}
107  plstream( PLINT nx /*=1*/, PLINT ny /*=1*/,
108  const char *driver = NULL, const char *file = NULL );
109  plstream( PLINT nx /*=1*/, PLINT ny /*=1*/, PLINT r, PLINT g, PLINT b,
110  const char *driver = NULL, const char *file = NULL );
111 
112  virtual ~plstream( void );
113 
114 // Now start miroring the PLplot C API.
115 
116  // C routines callable from stub routines come first
117 
118 // Advance to subpage "page", or to the next one if "page" = 0.
119 
120  void adv( PLINT page );
121 
122 // Plot an arc
123 
124  void arc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
125  PLFLT rotate, PLBOOL fill );
126 
127 // Simple arrow plotter
128 #ifdef PL_DEPRECATED
129  void arrows( const PLFLT *u, const PLFLT *v, const PLFLT *x, const PLFLT *y, PLINT n,
130  PLFLT scale, PLFLT dx, PLFLT dy );
131 #endif // PL_DEPRECATED
132 
133  void vect( const PLFLT * const *u, const PLFLT * const *v, PLINT nx, PLINT ny, PLFLT scale,
134  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
135  PLPointer pltr_data );
136 
137 // Set the arrow style
138  void svect( const PLFLT *arrow_x = NULL, const PLFLT *arrow_y = NULL, PLINT npts = 0, bool fill = false );
139 
140 // This functions similarly to plbox() except that the origin of the axes is
141 // placed at the user-specified point (x0, y0).
142 
143  void axes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
144  const char *yopt, PLFLT ytick, PLINT nysub );
145 
146 // Plot a histogram using x to store data values and y to store frequencies.
147 
148  void bin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center );
149 
150 // Start new page. Should only be used with pleop().
151 
152  void bop( void );
153 
154 // This draws a box around the current viewport.
155 
156  void box( const char *xopt, PLFLT xtick, PLINT nxsub,
157  const char *yopt, PLFLT ytick, PLINT nysub );
158 
159 // This is the 3-d analogue of plbox().
160 
161  void box3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
162  const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
163  const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz );
164 
165 // Calculate broken-down time from continuous time for current stream.
166 
167  void btime( PLINT &year, PLINT &month, PLINT &day, PLINT &hour,
168  PLINT &min, PLFLT &sec, PLFLT ctime );
169 
170 // Calculate world coordinates and subpage from relative device coordinates.
171 
172  void calc_world( PLFLT rx, PLFLT ry, PLFLT& wx, PLFLT& wy, PLINT& window );
173 
174 // Clear the current subpage.
175 
176  void clear( void );
177 
178 // Set color, map 0. Argument is integer between 0 and 15.
179 
180  void col0( PLINT icol0 );
181 
182 // Set the color using a descriptive name. Replaces plcol0(). (Except that
183 // col0 won't die.)
184 
185  void col( PLcolor c );
186 
187 // Set color, map 1. Argument is a float between 0. and 1.
188 
189  void col1( PLFLT c );
190 
191 // Previous function was inadvertently named plcol in old versions of
192 // plplot - this is maintained for backwards compatibility, but is best
193 // avoided in new code.
194  void col( PLFLT c );
195 
196 // Configure transformation between continuous and broken-down time (and
197 // vice versa) for current stream.
198  void configtime( PLFLT scale, PLFLT offset1, PLFLT offset2,
199  PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year,
200  PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec );
201 
202 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
203 // plfcont, with a particular choice for f2eval and f2eval_data.
204 
205  void cont( const PLFLT * const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
206  PLINT ky, PLINT ly, const PLFLT * clevel, PLINT nlevel,
207  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
208  PLPointer pltr_data );
209 
210 // Draws a contour plot using the function evaluator f2eval and data stored
211 // by way of the f2eval_data pointer. This allows arbitrary organizations
212 // of 2d array data to be used.
213 
214  void fcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
215  PLPointer f2eval_data,
216  PLINT nx, PLINT ny, PLINT kx, PLINT lx,
217  PLINT ky, PLINT ly, const PLFLT * clevel, PLINT nlevel,
218  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
219  PLPointer pltr_data );
220 
221 // Copies state parameters from the reference stream to the current stream.
222 
223  void cpstrm( plstream &pls, bool flags );
224 
225 // Calculate continuous time from broken-down time for current stream.
226  void ctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min,
227  PLFLT sec, PLFLT &ctime );
228 
229 // Converts input values from relative device coordinates to relative plot
230 // coordinates.
231 
232  void did2pc( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
233 
234 // Converts input values from relative plot coordinates to relative device
235 // coordinates.
236 
237  void dip2dc( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
238 
239 // These shouldn't be needed, are supposed to be handled by ctor/dtor
240 // semantics of the plstream object.
241 
242 // End a plotting session for all open streams.
243 
244 // void end();
245 
246 // End a plotting session for the current stream only.
247 
248 // void end1();
249 
250 // Simple interface for defining viewport and window.
251 
252  void env( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
253  PLINT just, PLINT axis );
254 
255 // similar to env() above, but in multiplot mode does not advance
256 // the subpage, instead the current subpage is cleared
257 
258  void env0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
259  PLINT just, PLINT axis );
260 
261 // End current page. Should only be used with plbop().
262 
263  void eop( void );
264 
265 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i)).
266 
267  void errx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y );
268 
269 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i)).
270 
271  void erry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax );
272 
273 // Advance to the next family file on the next new page.
274 
275  void famadv( void );
276 
277 // Pattern fills the polygon bounded by the input points.
278 
279  static void fill( PLINT n, const PLFLT *x, const PLFLT *y );
280 
281 // Pattern fills the 3d polygon bounded by the input points.
282 
283  static void fill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
284 
285 // Flushes the output stream. Use sparingly, if at all.
286 
287  void flush( void );
288 
289 // Sets the global font flag to 'ifont'.
290 
291  void font( PLINT ifont );
292 
293 // Load specified font set.
294 
295  void fontld( PLINT fnt );
296 
297 // Get character default height and current (scaled) height.
298 
299  void gchr( PLFLT& p_def, PLFLT& p_ht );
300 
301 // Returns 8 bit RGB values for given color from color map 0.
302 
303  void gcol0( PLINT icol0, PLINT& r, PLINT& g, PLINT& b );
304 
305 // Returns 8 bit RGB and 0.0-1.0 alpha values for given color from color map 0.
306 
307  void gcol0a( PLINT icol0, PLINT& r, PLINT& g, PLINT& b, PLFLT& a );
308 
309 // Returns the background color by 8 bit RGB value.
310 
311  void gcolbg( PLINT& r, PLINT& g, PLINT& b );
312 
313 // Returns the background color by 8 bit RGB and 0.0-1.0 alpha values.
314 
315  void gcolbga( PLINT& r, PLINT& g, PLINT& b, PLFLT& a );
316 
317 // Returns the current compression setting
318 
319  void gcompression( PLINT& compression );
320 
321 // Retrieve current window into device space.
322 
323  void gdidev( PLFLT& mar, PLFLT& aspect, PLFLT& jx, PLFLT& jy );
324 
325 // Get plot orientation.
326 
327  void gdiori( PLFLT& rot );
328 
329 // Retrieve current window into plot space.
330 
331  void gdiplt( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
332 
333 // Get FCI (font characterization integer)
334 
335  void gfci( PLUNICODE& pfci );
336 
337 // Get family file parameters.
338 
339  void gfam( PLINT& fam, PLINT& num, PLINT& bmax );
340 
341 // Get the (current) output file name. Must be preallocated to >80 bytes.
342 
343  void gfnam( char *fnam );
344 
345 // Get the current font family, style and weight
346 
347  void gfont( PLINT& family, PLINT& style, PLINT& weight );
348 
349 // Get the (current) run level.
350 
351  void glevel( PLINT &p_level );
352 
353 // Get output device parameters.
354 
355  void gpage( PLFLT& xp, PLFLT& yp, PLINT& xleng, PLINT& yleng,
356  PLINT& xoff, PLINT& yoff );
357 
358 // Switches to graphics screen.
359 
360  void gra( void );
361 
362 // Draw gradient in polygon.
363 
364  static void gradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle );
365 
366 // grid irregularly sampled data
367 
368  void griddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
369  const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
370  PLFLT **zg, PLINT type, PLFLT data );
371 
372 // Get subpage boundaries in absolute coordinates.
373 
374  void gspa( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
375 
376 // This shouldn't be needed in this model.
377 
378 // Get current stream number.
379 
380 // void gstrm( PLINT *p_strm );
381 
382 // Get the current library version number.
383 
384  void gver( char *p_ver );
385 
386 // Get the viewport window in normalized device coordinates
387 
388  void gvpd( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
389 
390 // Get the viewport window in world coordinates
391 
392  void gvpw( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
393 
394 // Get x axis labeling parameters.
395 
396  void gxax( PLINT& digmax, PLINT& digits );
397 
398 // Get y axis labeling parameters.
399 
400  void gyax( PLINT& digmax, PLINT& digits );
401 
402 // Get z axis labeling parameters
403 
404  void gzax( PLINT& digmax, PLINT& digits );
405 
406 // Draws a histogram of n values of a variable in array data[0..n-1]
407 
408  void hist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
409  PLINT nbin, PLINT oldwin );
410 
411 // Set current color (map 0) by hue, lightness, and saturation.
412 
413 #ifdef PL_DEPRECATED
414  void hls( PLFLT h, PLFLT l, PLFLT s );
415 #endif // PL_DEPRECATED
416 
417 // Initializes PLplot, using preset or default options
418 
419  void init( void );
420 
421 // Draws a line segment from (x1, y1) to (x2, y2).
422 
423  void join( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
424 
425 // Simple routine for labelling graphs.
426 
427  void lab( const char *xlabel, const char *ylabel, const char *tlabel );
428 
429 // Routine for drawing line, symbol, or cmap0 legends
430  void legend( PLFLT *p_legend_width, PLFLT *p_legend_height,
431  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
432  PLINT bg_color, PLINT bb_color, PLINT bb_style,
433  PLINT nrow, PLINT ncolumn,
434  PLINT nlegend, const PLINT *opt_array,
435  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
436  PLFLT text_justification,
437  const PLINT *text_colors, const char * const *text,
438  const PLINT *box_colors, const PLINT *box_patterns,
439  const PLFLT *box_scales, const PLFLT *box_line_widths,
440  const PLINT *line_colors, const PLINT *line_styles,
441  const PLFLT *line_widths,
442  const PLINT *symbol_colors, const PLFLT *symbol_scales,
443  const PLINT *symbol_numbers, const char * const *symbols );
444 
445  void colorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
446  PLINT opt, PLINT position, PLFLT x, PLFLT y,
447  PLFLT x_length, PLFLT y_length,
448  PLINT bg_color, PLINT bb_color, PLINT bb_style,
449  PLFLT low_cap_color, PLFLT high_cap_color,
450  PLINT cont_color, PLFLT cont_width,
451  PLINT n_labels, PLINT *label_opts, const char * const *label,
452  PLINT n_axes, const char * const *axis_opts,
453  PLFLT *ticks, PLINT *sub_ticks,
454  PLINT *n_values, const PLFLT * const *values );
455 
456 // Sets position of the light source
457 
458  void lightsource( PLFLT x, PLFLT y, PLFLT z );
459 
460 // Draws line segments connecting a series of points.
461 
462  void line( PLINT n, const PLFLT *x, const PLFLT *y );
463 
464 // Draws a line in 3 space.
465 
466  void line3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
467 
468 // Set line style.
469 
470  void lsty( PLINT lin );
471 
472 // plot continental outline in world coordinates
473 
474  void map( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), const char *type,
475  PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
476 
477 // Plot the latitudes and longitudes on the background.
478 
479  void meridians( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
480  PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong,
481  PLFLT minlat, PLFLT maxlat );
482 
483 // Plots a mesh representation of the function z[x][y].
484 
485  void mesh( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny, PLINT opt );
486 
487 // Plots a mesh representation of the function z[x][y] with contour.
488 
489  void meshc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny, PLINT opt,
490  const PLFLT *clevel, PLINT nlevel );
491 
492 // Creates a new stream and makes it the default.
493 
494 // void
495 // mkstrm(PLINT *p_strm);
496 
497 // Prints out "text" at specified position relative to viewport
498 
499  void mtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
500  const char *text );
501 
502 // Prints out "text" at specified position relative to viewport (3D)
503 
504  void mtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
505  const char *text );
506 
507 // Plots a 3-d representation of the function z[x][y].
508 
509  void plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
510  PLINT nx, PLINT ny, PLINT opt, bool side );
511 
512 // Plots a 3-d representation of the function z[x][y] with contour.
513 
514  void plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
515  PLINT nx, PLINT ny, PLINT opt,
516  const PLFLT *clevel, PLINT nlevel );
517 
518 // Plots a 3-d representation of the function z[x][y] with contour
519 // and y index limits.
520 
521  void plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
522  PLINT nx, PLINT ny, PLINT opt,
523  const PLFLT *clevel, PLINT nlevel,
524  PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
525 
526 
527 // Plots a 3-d shaded representation of the function z[x][y].
528 
529  void surf3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
530  PLINT nx, PLINT ny, PLINT opt,
531  const PLFLT *clevel, PLINT nlevel );
532 
533 // Plots a 3-d shaded representation of the function z[x][y] with y
534 // index limits
535 
536  void surf3dl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
537  PLINT nx, PLINT ny, PLINT opt,
538  const PLFLT *clevel, PLINT nlevel,
539  PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
540 
541 
542 // Process options list using current options info.
543 
544  int parseopts( int *p_argc, const char **argv, PLINT mode );
545 
546 // Set fill pattern directly.
547 
548  void pat( PLINT nlin, const PLINT *inc, const PLINT *del );
549 
550 // Draw a line connecting two points, accounting for coordinate transforms
551 
552  void path( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
553 
554 // Plots array y against x for n points using ASCII code "code".
555 
556  void poin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
557 
558 // Draws a series of points in 3 space.
559 
560  void poin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code );
561 
562 // Draws a polygon in 3 space.
563 
564  void poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const bool *draw, bool ifcc );
565 
566 // Set the floating point precision (in number of places) in numeric labels.
567 
568  void prec( PLINT setp, PLINT prec );
569 
570 // Set fill pattern, using one of the predefined patterns.
571 
572  void psty( PLINT patt );
573 
574 // Prints out "text" at world cooordinate (x,y).
575 
576  void ptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just,
577  const char *text );
578 
579 // Prints out "text" at world cooordinate (x,y,z).
580 
581  void ptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz,
582  PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text );
583 
584 // Replays contents of plot buffer to current device/file.
585 
586  void replot( void );
587 
588 // Set line color by red, green, blue from 0. to 1.
589 
590 #ifdef PL_DEPRECATED
591  void rgb( PLFLT r, PLFLT g, PLFLT b );
592 #endif // PL_DEPRECATED
593 
594 // Set line color by 8 bit RGB values.
595 
596 #ifdef PL_DEPRECATED
597  void rgb( PLINT r, PLINT g, PLINT b );
598 #endif // PL_DEPRECATED
599 
600 // Set character height.
601 
602  void schr( PLFLT def, PLFLT scale );
603 
604 // Set number of colors in cmap 0
605 
606  void scmap0n( PLINT ncol0 );
607 
608 // Set number of colors in cmap 1
609 
610  void scmap1n( PLINT ncol1 );
611 
612 // Set the color map 1 range used in continuous plots
613 
614  void scmap1_range( PLFLT min_color, PLFLT max_color );
615 
616 // Get the color map 1 range used in continuous plots
617 
618  void gcmap1_range( PLFLT &min_color, PLFLT &max_color );
619 
620 // Set color map 0 colors by 8 bit RGB values
621 
622  void scmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 );
623 
624 // Set color map 0 colors by 8 bit RGB values and alpha value (0.0-1.0)
625 
626  void scmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 );
627 
628 // Set color map 1 colors by 8 bit RGB values
629 
630  void scmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 );
631 
632 // Set color map 1 colors by 8 bit RGB values and alpha value (0.0-1.0)
633 
634  void scmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 );
635 
636 // Set color map 1 colors using a piece-wise linear relationship between
637 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
638 
639  void scmap1l( bool itype, PLINT npts, const PLFLT *intensity,
640  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const bool *alt_hue_path = NULL );
641 
642 // void scmap1l( bool itype, PLINT npts, PLFLT *intensity,
643 // PLFLT *coord1, PLFLT *coord2, PLFLT *coord3 );
644 
645 // Set color map 1 colors using a piece-wise linear relationship between
646 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
647 // Include alpha value in range 0.0-1.0.
648 
649  void scmap1la( bool itype, PLINT npts, const PLFLT *intensity,
650  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLFLT *a,
651  const bool *alt_hue_path = NULL );
652 
653 // Set a given color from color map 0 by 8 bit RGB value
654 
655  void scol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
656 
657 // Set a given color from color map 0 by 8 bit RGB value and alpha value (0.0-1.0)
658 
659  void scol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
660 
661 // Set the background color by 8 bit RGB value
662 
663  void scolbg( PLINT r, PLINT g, PLINT b );
664 
665 // Set the background color by 8 bit RGB + alpha value
666 
667  void scolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
668 
669 // Used to globally turn color output on/off
670 
671  void scolor( PLINT color );
672 
673 // Set the compression level
674 
675  void scompression( PLINT compression );
676 
677 // Set the device (keyword) name
678 
679  void sdev( const char *devname );
680 
681 // Get the device (keyword) name
682 
683  void gdev( char *devname );
684 
685 // Set window into device space using margin, aspect ratio, and
686 // justification
687 
688  void sdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
689 
690 // Set up transformation from metafile coordinates.
691 
692  void sdimap( PLINT dimxmin, PLINT dimxmax,
693  PLINT dimymin, PLINT dimymax,
694  PLFLT dimxpmm, PLFLT dimypmm );
695 
696 // Set plot orientation, specifying rotation in units of pi/2.
697 
698  void sdiori( PLFLT rot );
699 
700 // Set window into plot space
701 
702  void sdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
703 
704 // Set window into plot space incrementally (zoom)
705 
706  void sdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
707 
708 // Set the escape character for text strings.
709 
710  void sesc( char esc );
711 
712 // Set offset and spacing of contour labels
713 
714  void setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing,
715  PLINT active );
716 
717 // Set the format of the contour labels
718 
719  void setcontlabelformat( PLINT lexp, PLINT sigdig );
720 
721 // Set family file parameters
722 
723  void sfam( PLINT fam, PLINT num, PLINT bmax );
724 
725 // Set FCI (font characterization integer)
726 
727  void sfci( PLUNICODE fci );
728 
729 // Set the output file name.
730 
731  void sfnam( const char *fnam );
732 
733 // Set the current font family, style and weight
734 
735  void sfont( PLINT family, PLINT style, PLINT weight );
736 
737 // Shade region.
738 
739  void shade( const PLFLT * const *a, PLINT nx, PLINT ny,
740  PLINT ( *defined )( PLFLT, PLFLT ),
741  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
742  PLFLT shade_min, PLFLT shade_max,
743  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
744  PLINT min_color, PLFLT min_width,
745  PLINT max_color, PLFLT max_width,
746  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
747  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
748  PLPointer pltr_data );
749 
750  void shades( const PLFLT * const *a, PLINT nx, PLINT ny,
751  PLINT ( *defined )( PLFLT, PLFLT ),
753  const PLFLT * clevel, PLINT nlevel, PLFLT fill_width,
754  PLINT cont_color, PLFLT cont_width,
755  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
756  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
757  PLPointer pltr_data );
758 
759 // Would be nice to fix this even more, say by stuffing xmin, xmax,
760 // ymin, ymax, rectangular, and pcxf all into the contourable data
761 // class. Have to think more on that. Or maybe the coordinate info.
762 
763  void shade( Contourable_Data& d, PLFLT xmin, PLFLT xmax,
764  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
765  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
766  PLINT min_color, PLFLT min_width,
767  PLINT max_color, PLFLT max_width,
768  bool rectangular,
769  Coord_Xformer *pcxf );
770 
771  void shade1( const PLFLT * a, PLINT nx, PLINT ny,
772  PLINT ( *defined )( PLFLT, PLFLT ),
773  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
774  PLFLT shade_min, PLFLT shade_max,
775  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
776  PLINT min_color, PLFLT min_width,
777  PLINT max_color, PLFLT max_width,
778  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
779  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
780  PLPointer pltr_data );
781 
782  void fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
783  PLPointer f2eval_data,
784  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
785  PLPointer c2eval_data,
786  PLINT nx, PLINT ny,
787  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
788  PLFLT shade_min, PLFLT shade_max,
789  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
790  PLINT min_color, PLFLT min_width,
791  PLINT max_color, PLFLT max_width,
792  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
793  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
794  PLPointer pltr_data );
795 
796 // Setup a user-provided custom labeling function
797 
798  void slabelfunc( void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer ),
799  PLPointer label_data );
800 
801 // Set up lengths of major tick marks.
802 
803  void smaj( PLFLT def, PLFLT scale );
804 
805 // Set the RGB memory area to be plotted (with the 'mem' or 'memcairo' drivers)
806 
807  void smem( PLINT maxx, PLINT maxy, void *plotmem );
808 
809 // Set the RGBA memory area to be plotted (with the 'memcairo' driver)
810 
811  void smema( PLINT maxx, PLINT maxy, void *plotmem );
812 
813 // Set up lengths of minor tick marks.
814 
815  void smin( PLFLT def, PLFLT scale );
816 
817 // Set orientation. Must be done before calling plinit.
818 
819  void sori( PLINT ori );
820 
821 // Set output device parameters. Usually ignored by the driver.
822 
823  void spage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
824  PLINT xoff, PLINT yoff );
825 
826 // Set the pause (on end-of-page) status
827 
828  void spause( bool pause );
829 
830 // Set the colors for color table 0 from a cmap0 file
831 
832  void spal0( const char *filename );
833 
834 // Set the colors for color table 1 from a cmap1 file
835 
836  void spal1( const char *filename, bool interpolate = true );
837 
838 // Set stream number.
839 
840  void sstrm( PLINT strm );
841 
842 // Set the number of subwindows in x and y
843 
844  void ssub( PLINT nx, PLINT ny );
845 
846 // Set symbol height.
847 
848  void ssym( PLFLT def, PLFLT scale );
849 
850 // Initialize PLplot, passing in the windows/page settings.
851 
852  void star( PLINT nx, PLINT ny );
853 
854 // Initialize PLplot, passing the device name and windows/page settings.
855 
856  void start( const char *devname, PLINT nx, PLINT ny );
857 
858 // Set the coordinate transform
859 
860  void stransform( void ( *coordinate_transform )( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ), PLPointer coordinate_transform_data );
861 
862 // Prints out the same string repeatedly at the n points in world
863 // coordinates given by the x and y arrays. Supersedes plpoin and
864 // plsymbol for the case where text refers to a unicode glyph either
865 // directly as UTF-8 or indirectly via the standard text escape
866 // sequences allowed for PLplot input strings.
867 
868  void string( PLINT n, const PLFLT *x, const PLFLT *y, const char *string );
869 
870 // Prints out the same string repeatedly at the n points in world
871 // coordinates given by the x, y, and z arrays. Supersedes plpoin3
872 // for the case where text refers to a unicode glyph either directly
873 // as UTF-8 or indirectly via the standard text escape sequences
874 // allowed for PLplot input strings.
875 
876  void string3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string );
877 
878 // Create 1d stripchart
879 
880  void stripc( PLINT *id, const char *xspec, const char *yspec,
881  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
882  PLFLT xlpos, PLFLT ylpos,
883  bool y_ascl, bool acc,
884  PLINT colbox, PLINT collab,
885  const PLINT colline[], const PLINT styline[], const char *legline[],
886  const char *labx, const char *laby, const char *labtop );
887 
888 // Add a point to a stripchart.
889 
890  void stripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
891 
892 // Deletes and releases memory used by a stripchart.
893 
894  void stripd( PLINT id );
895 
896 // plots a 2d image (or a matrix too large for plshade() ) - colors
897 // automatically scaled
898 
899  void image( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
900  PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
901  PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
902 
903 // plots a 2d image (or a matrix too large for plshade() )
904 
905  void imagefr( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
906  PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
907  PLFLT valuemin, PLFLT valuemax,
908  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
909  PLPointer pltr_data );
910 
911 // Set up a new line style
912 
913  void styl( PLINT nms, const PLINT *mark, const PLINT *space );
914 
915 // Sets the edges of the viewport to the specified absolute coordinates
916 
917  void svpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
918 
919 // Set x axis labeling parameters
920 
921  void sxax( PLINT digmax, PLINT digits );
922 
923 // Set inferior X window
924 
925  void sxwin( PLINT window_id );
926 
927 // Set y axis labeling parameters
928 
929  void syax( PLINT digmax, PLINT digits );
930 
931 // Plots array y against x for n points using Hershey symbol "code"
932 
933  void sym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
934 
935 // Set z axis labeling parameters
936 
937  void szax( PLINT digmax, PLINT digits );
938 
939 // Switches to text screen.
940 
941  void text( void );
942 
943 // Set the format for date / time labels
944 
945  void timefmt( const char *fmt );
946 
947 // Sets the edges of the viewport with the given aspect ratio, leaving
948 // room for labels.
949 
950  void vasp( PLFLT aspect );
951 
952 // Creates the largest viewport of the specified aspect ratio that fits
953 // within the specified normalized subpage coordinates.
954 
955  void vpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
956 
957 // Creates a viewport with the specified normalized subpage coordinates.
958 
959  void vpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
960 
961 // Defines a "standard" viewport with seven character heights for
962 // the left margin and four character heights everywhere else.
963 
964  void vsta( void );
965 
966 // Set up a window for three-dimensional plotting.
967 
968  void w3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
969  PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
970  PLFLT zmax0, PLFLT alt, PLFLT az );
971 
972 // Set pen width.
973 
974  void width( PLFLT width );
975 
976 // Set up world coordinates of the viewport boundaries (2d plots).
977 
978  void wind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
979 
980 // Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
981  void xormod( bool mode, bool *status );
982 
983 // Random number generator based on Mersenne Twister.
984 // Functions to set seed and obtain real random numbers in the range [0,1].
985 
986  void seed( unsigned int s );
987 
988  PLFLT randd( void );
989 
990 
991  // The rest for use from C only
992 
993 // Returns a list of file-oriented device names and their menu strings
994 
995  void gFileDevs( const char ***p_menustr, const char ***p_devname,
996  int *p_ndev );
997 
998 // Set the function pointer for the keyboard event handler
999 
1000  void sKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ),
1001  void *KeyEH_data );
1002 
1003 // Sets an optional user bop handler
1004 
1005  void sbopH( void ( *handler )( void *, int * ), void *handlier_data );
1006 
1007 // Sets an optional user eop handler
1008 
1009  void seopH( void ( *handler )( void *, int * ), void *handlier_data );
1010 
1011 // Set the variables to be used for storing error info
1012 
1013  void sError( PLINT *errcode, char *errmsg );
1014 
1015 // Sets an optional user exit handler.
1016 
1017  void sexit( int ( *handler )( const char * ) );
1018 
1019  // Transformation routines
1020 
1021 // Identity transformation.
1022 
1023  static void tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1024 
1025 // Does linear interpolation from singly dimensioned coord arrays.
1026 
1027  static void tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1028 
1029 // Does linear interpolation from doubly dimensioned coord arrays
1030 // (column dominant, as per normal C 2d arrays).
1031 
1032  static void tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1033 
1034 // Just like pltr2() but uses pointer arithmetic to get coordinates from
1035 // 2d grid tables.
1036 
1037  static void tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1038 
1039 // We obviously won't be using this object from Fortran...
1040 
1041 // Identity transformation for plots from Fortran.
1042 
1043 // void tr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
1044 
1045 // Does linear interpolation from doubly dimensioned coord arrays
1046 // (row dominant, i.e. Fortran ordering).
1047 
1048 // void tr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
1049 
1050 // Example linear transformation function for contour plotter.
1051 // This is not actually part of the core library any more
1052  //void xform( PLFLT x, PLFLT y, PLFLT * tx, PLFLT * ty );
1053 
1054  // Function evaluators
1055 
1056 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
1057 // and is column dominant (normal C ordering).
1058 
1059  PLFLT f2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
1060 
1061 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
1062 // and is column dominant (normal C ordering).
1063 
1064  PLFLT f2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
1065 
1066 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
1067 // and is row dominant (Fortran ordering).
1068 
1069  PLFLT f2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
1070 
1071  // Command line parsing utilities
1072 
1073 // Clear internal option table info structure.
1074 
1075  void ClearOpts( void );
1076 
1077 // Reset internal option table info structure.
1078 
1079  void ResetOpts( void );
1080 
1081 // Merge user option table into internal info structure.
1082 
1083  int MergeOpts( PLOptionTable *options, const char *name, const char **notes );
1084 
1085 // Set the strings used in usage and syntax messages.
1086 
1087  void SetUsage( char *program_string, char *usage_string );
1088 
1089 // Process input strings, treating them as an option and argument pair.
1090 
1091  int setopt( const char *opt, const char *optarg );
1092 
1093 // This version is for backward compatibility only - don't use in new code
1094 
1095  int SetOpt( const char *opt, const char *optarg );
1096 
1097 // Process options list using current options info.
1098 
1099  int ParseOpts( int *p_argc, const char **argv, PLINT mode );
1100 
1101 // Print usage & syntax message.
1102 
1103  void OptUsage( void );
1104 
1105  // Miscellaneous
1106 
1107 // Set the output file pointer
1108 
1109  void gfile( FILE **p_file );
1110 
1111 // Get the output file pointer
1112 
1113  void sfile( FILE *file );
1114 
1115 // Get the escape character for text strings.
1116 
1117  void gesc( char *p_esc );
1118 
1119 // Front-end to driver escape function.
1120 
1121  void cmd( PLINT op, void *ptr );
1122 
1123 // Return full pathname for given file if executable
1124 
1125  int FindName( char *p );
1126 
1127 // Looks for the specified executable file according to usual search path.
1128 
1129  char *FindCommand( char *fn );
1130 
1131 // Gets search name for file by concatenating the dir, subdir, and file
1132 // name, allocating memory as needed.
1133 
1134  void GetName( char *dir, char *subdir, char *filename, char **filespec );
1135 
1136 // Prompts human to input an integer in response to given message.
1137 
1138  PLINT GetInt( char *s );
1139 
1140 // Prompts human to input a float in response to given message.
1141 
1142  PLFLT GetFlt( char *s );
1143 
1144  // Nice way to allocate space for a vectored 2d grid
1145 
1146 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
1147 
1148  void Alloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
1149 
1150 // Frees a block of memory allocated with plAlloc2dGrid().
1151 
1152  void Free2dGrid( PLFLT **f, PLINT nx, PLINT ny );
1153 
1154 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
1155  void MinMax2dGrid( const PLFLT * const *f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
1156 
1157 // Functions for converting between HLS and RGB color space
1158 
1159  void hlsrgb( PLFLT h, PLFLT l, PLFLT s,
1160  PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
1161 
1162  void rgbhls( PLFLT r, PLFLT g, PLFLT b,
1163  PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
1164 
1165 // Wait for graphics input event and translate to world coordinates
1166 
1167  int GetCursor( PLGraphicsIn *plg );
1168 
1169 // Deprecated versions of methods which use PLINT instead of bool
1170  void svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, PLINT fill );
1171  void cpstrm( plstream &pls, PLINT flags );
1172  void plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1173  PLINT nx, PLINT ny, PLINT opt, PLINT side );
1174  void poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const PLINT *draw, PLINT ifcc );
1175  void scmap1l( PLINT itype, PLINT npts, const PLFLT *intensity,
1176  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLINT *alt_hue_path );
1177 
1178  void shade( const PLFLT * const *a, PLINT nx, PLINT ny,
1179  PLINT ( *defined )( PLFLT, PLFLT ),
1180  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1181  PLFLT shade_min, PLFLT shade_max,
1182  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1183  PLINT min_color, PLFLT min_width,
1184  PLINT max_color, PLFLT max_width,
1185  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
1186  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
1187  PLPointer pltr_data );
1188 
1189  void shades( const PLFLT * const *a, PLINT nx, PLINT ny, PLINT ( *defined )( PLFLT,
1190  PLFLT ),
1191  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
1192  const PLFLT * clevel, PLINT nlevel, PLFLT fill_width,
1193  PLINT cont_color, PLFLT cont_width,
1194  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
1195  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
1196  PLPointer pltr_data );
1197 
1198  void shade( Contourable_Data& d, PLFLT xmin, PLFLT xmax,
1199  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
1200  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1201  PLINT min_color, PLFLT min_width,
1202  PLINT max_color, PLFLT max_width,
1203  PLINT rectangular,
1204  Coord_Xformer *pcxf );
1205 
1206  void shade1( const PLFLT * a, PLINT nx, PLINT ny,
1207  PLINT ( *defined )( PLFLT, PLFLT ),
1208  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1209  PLFLT shade_min, PLFLT shade_max,
1210  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1211  PLINT min_color, PLFLT min_width,
1212  PLINT max_color, PLFLT max_width,
1213  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
1214  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
1215  PLPointer pltr_data );
1216 
1217  void fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
1218  PLPointer f2eval_data,
1219  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
1220  PLPointer c2eval_data,
1221  PLINT nx, PLINT ny,
1222  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1223  PLFLT shade_min, PLFLT shade_max,
1224  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1225  PLINT min_color, PLFLT min_width,
1226  PLINT max_color, PLFLT max_width,
1227  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
1228  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
1229  PLPointer pltr_data );
1230 
1231  void spause( PLINT pause );
1232 
1233  void stripc( PLINT *id, const char *xspec, const char *yspec,
1234  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
1235  PLFLT xlpos, PLFLT ylpos,
1236  PLINT y_ascl, PLINT acc,
1237  PLINT colbox, PLINT collab,
1238  const PLINT colline[], const PLINT styline[], const char *legline[],
1239  const char *labx, const char *laby, const char *labtop );
1240 
1241  void xormod( PLINT mode, PLINT *status );
1242 };
1243 
1244 
1245 
1246 #endif // __plstream_h__
1247 
1248 //--------------------------------------------------------------------------
1249 // end of plstream.h
1250 //--------------------------------------------------------------------------