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