PLplot  5.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplot.d
Go to the documentation of this file.
1 // Converted to D from plplot_d.h by htod
2 module plplot;
3 
4 private import std.string;
5 private import std.array;
6 private import std.algorithm;
7 private import std.stdio;
8 private import std.conv;
9 
10 // improved D interface
11 
12 // certain functions must be declared as C functions so that PLplot
13 // can handle them
14 extern ( C ) {
15 alias PLINT function( PLFLT, PLFLT ) def_func;
16 alias void function( PLINT, PLFLT*, PLFLT* ) fill_func;
17 alias void function( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ) pltr_func;
18 alias void function( PLINT, PLFLT*, PLFLT* ) mapform_func;
19 alias void function( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ) ct_func;
20 }
21 
22 // D definition of PLcGrid and PLcGrid2
23 struct PLcGrid
24 {
25  PLFLT[] xg;
26  PLFLT[] yg;
27  PLFLT[] zg;
28 }
29 struct PLcGrid2
30 {
31  PLFLT[][] xg;
32  PLFLT[][] yg;
33  PLFLT[][] zg;
34 }
35 
36 // helper function to convert D dynamic arrays in C dynamic arrays
37 private PLFLT** convert_array( PLFLT[][] a )
38 {
39  if ( !a )
40  return null;
41 
42  size_t nx = a.length;
43  size_t ny = a[0].length;
44 
45  PLFLT ** c_a = ( new PLFLT *[nx] ).ptr;
46  for ( size_t i = 0; i < nx; i++ )
47  {
48  assert( ny == a[i].length, "convert_array(): Array must be 2 dimensional!" );
49  c_a[i] = a[i].ptr;
50  }
51 
52  return c_a;
53 }
54 
55 // Process options list using current options info.
56 int plparseopts( char[][] args, PLINT mode )
57 {
58  char*[] c_args = new char*[args.length];
59  foreach ( size_t i, char[] arg; args )
60  c_args[i] = cast(char *) toStringz( arg );
61  int argc = cast(int) c_args.length;
62  return c_plparseopts( &argc, cast(char**) c_args, mode );
63 }
64 
65 // simple arrow plotter.
66 void plvect( PLFLT[][] u, PLFLT[][] v, PLFLT scale, pltr_func pltr = null, PLPointer pltr_data = null )
67 {
68  PLINT nx = cast(PLINT) u.length;
69  PLINT ny = cast(PLINT) u[0].length;
70  assert( nx == v.length, "plvect(): Arrays must be of same length!" );
71  assert( ny == v[0].length, "plvect(): Arrays must be of same length!" );
72 
73  c_plvect( convert_array( u ), convert_array( v ), nx, ny, scale, pltr, pltr_data );
74 }
75 
76 void plvect( PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid cgrid )
77 {
78  PLINT nx = cast(PLINT) u.length;
79  PLINT ny = cast(PLINT) u[0].length;
80  assert( nx == v.length, "plvect(): Arrays must be of same length!" );
81  assert( ny == v[0].length, "plvect(): Arrays must be of same length!" );
82 
83  c_PLcGrid c;
84  c.xg = cgrid.xg.ptr;
85  c.nx = cast(PLINT) cgrid.xg.length;
86  c.yg = cgrid.yg.ptr;
87  c.ny = cast(PLINT) cgrid.yg.length;
88  c.zg = cgrid.zg.ptr;
89  c.nz = cast(PLINT) cgrid.zg.length;
90 
91  c_plvect( convert_array( u ), convert_array( v ), nx, ny, scale, &pltr1, &c );
92 }
93 
94 void plvect( PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid2 cgrid2 )
95 {
96  PLINT nx = cast(PLINT) u.length;
97  PLINT ny = cast(PLINT) u[0].length;
98  assert( nx == v.length, "plvect(): Arrays must be of same length!" );
99  assert( ny == v[0].length, "plvect(): Arrays must be of same length!" );
100 
101  c_PLcGrid2 c2;
102  c2.xg = convert_array( cgrid2.xg );
103  c2.yg = convert_array( cgrid2.yg );
104  c2.zg = convert_array( cgrid2.zg );
105  c2.nx = cast(PLINT) cgrid2.xg.length;
106  c2.ny = cast(PLINT) cgrid2.xg[0].length;
107  if ( cgrid2.yg )
108  {
109  assert( c2.nx == cgrid2.yg.length, "plvect(): Arrays must be of same length!" );
110  assert( c2.ny == cgrid2.yg[0].length, "plvect(): Arrays must be of same length!" );
111  }
112  if ( cgrid2.zg )
113  {
114  assert( c2.nx == cgrid2.zg.length, "plvect(): Arrays must be of same length!" );
115  assert( c2.ny == cgrid2.zg[0].length, "plvect(): Arrays must be of same length!" );
116  }
117 
118  c_plvect( convert_array( u ), convert_array( v ), nx, ny, scale, &pltr2, &c2 );
119 }
120 
121 void plsvect( PLFLT[] arrowx, PLFLT[] arrowy, PLBOOL fill )
122 {
123  PLINT npts = cast(PLINT) arrowx.length;
124  assert( npts == arrowy.length, "plsvect(): Arrays must be of same length!" );
125  c_plsvect( arrowx.ptr, arrowy.ptr, npts, fill );
126 }
127 
128 // This functions similarly to plbox() except that the origin of the axes
129 // is placed at the user-specified point (x0, y0).
130 void plaxes( PLFLT x0, PLFLT y0, string xopt, PLFLT xtick, PLINT nxsub,
131  string yopt, PLFLT ytick, PLINT nysub )
132 {
133  c_plaxes( x0, y0, toStringz( xopt ), xtick, nxsub, toStringz( yopt ), ytick, nysub );
134 }
135 
136 // Plot a histogram using x to store data values and y to store frequencies
137 void plbin( PLFLT[] x, PLFLT[] y, PLINT opt )
138 {
139  PLINT nbin = cast(PLINT) x.length;
140  assert( nbin == y.length, "plbin(): Arrays must be of same length!" );
141  c_plbin( nbin, x.ptr, y.ptr, opt );
142 }
143 
144 // This draws a box around the current viewport.
145 void plbox( string xopt, PLFLT xtick, PLINT nxsub, string yopt, PLFLT ytick, PLINT nysub )
146 {
147  c_plbox( toStringz( xopt ), xtick, nxsub, toStringz( yopt ), ytick, nysub );
148 }
149 
150 // This is the 3-d analogue of plbox().
151 void plbox3( string xopt, string xlabel, PLFLT xtick, PLINT nsubx,
152  string yopt, string ylabel, PLFLT ytick, PLINT nsuby,
153  string zopt, string zlabel, PLFLT ztick, PLINT nsubz )
154 {
155  c_plbox3( toStringz( xopt ), toStringz( xlabel ), xtick, nsubx,
156  toStringz( yopt ), toStringz( ylabel ), ytick, nsuby,
157  toStringz( zopt ), toStringz( zlabel ), ztick, nsubz );
158 }
159 
160 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
161 // plfcont, with a particular choice for f2eval and f2eval_data.
162 //
163 void plcont( PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel,
164  pltr_func pltr, PLPointer pltr_data = null )
165 {
166  PLINT nx = cast(PLINT) f.length;
167  PLINT ny = cast(PLINT) f[0].length;
168 
169  c_plcont( convert_array( f ), nx, ny, kx, lx, ky, ly, clevel.ptr, cast(PLINT) clevel.length,
170  pltr, pltr_data );
171 }
172 
173 void plcont( PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel,
174  ref PLcGrid cgrid )
175 {
176  PLINT nx = cast(PLINT) f.length;
177  PLINT ny = cast(PLINT) f[0].length;
178 
179  c_PLcGrid c;
180  c.xg = cgrid.xg.ptr;
181  c.nx = cast(PLINT) cgrid.xg.length;
182  c.yg = cgrid.yg.ptr;
183  c.ny = cast(PLINT) cgrid.yg.length;
184  c.zg = cgrid.zg.ptr;
185  c.nz = cast(PLINT) cgrid.zg.length;
186 
187  c_plcont( convert_array( f ), nx, ny, kx, lx, ky, ly, clevel.ptr, cast(PLINT) clevel.length,
188  &pltr1, &c );
189 }
190 
191 void plcont( PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel,
192  ref PLcGrid2 cgrid2 )
193 {
194  PLINT nx = cast(PLINT) f.length;
195  PLINT ny = cast(PLINT) f[0].length;
196 
197  c_PLcGrid2 c2;
198  c2.xg = convert_array( cgrid2.xg );
199  c2.yg = convert_array( cgrid2.yg );
200  c2.zg = convert_array( cgrid2.zg );
201  c2.nx = cast(PLINT) cgrid2.xg.length;
202  c2.ny = cast(PLINT) cgrid2.xg[0].length;
203  if ( cgrid2.yg )
204  {
205  assert( c2.nx == cgrid2.yg.length, "plcont(): Arrays must be of same length!" );
206  assert( c2.ny == cgrid2.yg[0].length, "plcont(): Arrays must be of same length!" );
207  }
208  if ( cgrid2.zg )
209  {
210  assert( c2.nx == cgrid2.zg.length, "plcont(): Arrays must be of same length!" );
211  assert( c2.ny == cgrid2.zg[0].length, "plcont(): Arrays must be of same length!" );
212  }
213 
214  c_plcont( convert_array( f ), nx, ny, kx, lx, ky, ly, clevel.ptr, cast(PLINT) clevel.length,
215  &pltr2, &c2 );
216 }
217 
218 // Draws a contour plot using the function evaluator f2eval and data stored
219 // by way of the f2eval_data pointer. This allows arbitrary organizations
220 // of 2d array data to be used.
221 //
222 //void plfcont(PLFLT function(PLINT , PLINT , PLPointer )f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, void function(PLFLT , PLFLT , PLFLT *, PLFLT *, PLPointer )pltr, PLPointer pltr_data);
223 
224 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))
225 void plerrx( PLFLT[] xmin, PLFLT[] xmax, PLFLT[] y )
226 {
227  PLINT n = cast(PLINT) y.length;
228  assert( n == xmin.length, "plerrx(): Arrays must be of same length!" );
229  assert( n == xmax.length, "plerrx(): Arrays must be of same length!" );
230  c_plerrx( n, xmin.ptr, xmax.ptr, y.ptr );
231 }
232 
233 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))
234 void plerry( PLFLT[] x, PLFLT[] ymin, PLFLT[] ymax )
235 {
236  PLINT n = cast(PLINT) x.length;
237  assert( n == ymin.length, "plerry(): Arrays must be of same length!" );
238  assert( n == ymax.length, "plerry(): Arrays must be of same length!" );
239  c_plerry( n, x.ptr, ymin.ptr, ymax.ptr );
240 }
241 
242 // Pattern fills the polygon bounded by the input points.
243 void plfill( PLFLT[] x, PLFLT[] y )
244 {
245  PLINT n = cast(PLINT) x.length;
246  assert( n == y.length, "plfill(): Arrays must be of same length!" );
247  c_plfill( n, x.ptr, y.ptr );
248 }
249 
250 // Pattern fills the 3d polygon bounded by the input points.
251 void plfill3( PLFLT[] x, PLFLT[] y, PLFLT[] z )
252 {
253  PLINT n = cast(PLINT) x.length;
254  assert( n == y.length, "plfill3(): Arrays must be of same length!" );
255  assert( n == z.length, "plfill3(): Arrays must be of same length!" );
256  c_plfill3( n, x.ptr, y.ptr, z.ptr );
257 }
258 
259 // Get the current device (keyword) name
260 void plgdev( out string p_dev )
261 {
262  char cdev[1024];
263  c_plgdev( cdev.ptr );
264  p_dev = to!string( cdev.ptr );
265 }
266 
267 // Get the (current) output file name. Must be preallocated to >80 bytes
268 void plgfnam( out string fnam )
269 {
270  char cfnam[1024];
271  c_plgfnam( cfnam.ptr );
272  fnam = to!string( cfnam.ptr );
273 }
274 
275 // Draw gradient in polygon.
276 void plgradient( PLFLT[] x, PLFLT[] y, PLFLT angle )
277 {
278  PLINT n = cast(PLINT) x.length;
279  assert( n == y.length, "plgradient(): Arrays must be of same length!" );
280  c_plgradient( n, x.ptr, y.ptr, angle );
281 }
282 
283 // grid irregularly sampled data
284 void plgriddata( PLFLT[] x, PLFLT[] y, PLFLT[] z, PLFLT[] xg, PLFLT[] yg, PLFLT[][] zg, PLINT type, PLFLT data )
285 {
286  PLINT npts = cast(PLINT) x.length;
287  assert( npts == y.length, "plgriddata(): Arrays must be of same length!" );
288  assert( npts == z.length, "plgriddata(): Arrays must be of same length!" );
289 
290  PLINT nxg = cast(PLINT) xg.length;
291  PLINT nyg = cast(PLINT) yg.length;
292  assert( nxg == zg.length, "plgriddata(): Arrays must be of same length!" );
293  assert( nyg == zg[0].length, "plgriddata(): Arrays must be of same length!" );
294 
295  c_plgriddata( x.ptr, y.ptr, z.ptr, npts, xg.ptr, nxg, yg.ptr, nyg, convert_array( zg ), type, data );
296 }
297 
298 // Get the current library version number
299 void plgver( out string p_ver )
300 {
301  char cver[1024];
302  c_plgver( cver.ptr );
303  p_ver = to!string( cver.ptr );
304 }
305 
306 // Draws a histogram of n values of a variable in array data[0..n-1]
307 void plhist( PLFLT[] data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt )
308 {
309  c_plhist( cast(PLINT) data.length, data.ptr, datmin, datmax, nbin, opt );
310 }
311 
312 // Simple routine for labelling graphs.
313 void pllab( string xlabel, string ylabel, string tlabel )
314 {
315  c_pllab( toStringz( xlabel ), toStringz( ylabel ), toStringz( tlabel ) );
316 }
317 
318 // Routine for drawing discrete line, symbol, or cmap0 legends
319 void pllegend( PLFLT *p_legend_width, PLFLT *p_legend_height,
320  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
322  PLINT nrow, PLINT ncolumn,
323  PLINT[] opt_array,
324  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
325  PLFLT text_justification,
326  PLINT[] text_colors, string[] text,
327  PLINT[] box_colors, PLINT[] box_patterns,
328  PLFLT[] box_scales, PLFLT[] box_line_widths,
329  PLINT[] line_colors, PLINT[] line_styles,
330  PLFLT[] line_widths,
331  PLINT[] symbol_colors, PLFLT[] symbol_scales,
332  PLINT[] symbol_numbers, string[] symbols )
333 {
334  PLINT nlegend = cast(PLINT) opt_array.length;
335  immutable( char ) * *textz = array( map!toStringz( text ) ).ptr;
336  immutable( char ) * *symbolsz = array( map!toStringz( symbols ) ).ptr;
337  assert( nlegend == text_colors.length, "pllegend(): Arrays must be of same length!" );
338  assert( nlegend == text.length, "pllegend(): Arrays must be of same length!" );
339  assert( nlegend == box_colors.length, "pllegend(): Arrays must be of same length!" );
340  assert( nlegend == box_patterns.length, "pllegend(): Arrays must be of same length!" );
341  assert( nlegend == box_scales.length, "pllegend(): Arrays must be of same length!" );
342  assert( nlegend == box_line_widths.length, "pllegend(): Arrays must be of same length!" );
343  assert( nlegend == line_colors.length, "pllegend(): Arrays must be of same length!" );
344  assert( nlegend == line_styles.length, "pllegend(): Arrays must be of same length!" );
345  assert( nlegend == line_widths.length, "pllegend(): Arrays must be of same length!" );
346  assert( nlegend == symbol_colors.length, "pllegend(): Arrays must be of same length!" );
347  assert( nlegend == symbol_scales.length, "pllegend(): Arrays must be of same length!" );
348  assert( nlegend == symbol_numbers.length, "pllegend(): Arrays must be of same length!" );
349  assert( nlegend == symbols.length, "pllegend(): Arrays must be of same length!" );
350  c_pllegend( p_legend_width, p_legend_height,
351  opt, position, x, y, plot_width,
352  bg_color, bb_color, bb_style,
353  nrow, ncolumn,
354  nlegend, opt_array.ptr,
355  text_offset, text_scale, text_spacing,
356  text_justification,
357  text_colors.ptr, textz,
358  box_colors.ptr, box_patterns.ptr,
359  box_scales.ptr, box_line_widths.ptr,
360  line_colors.ptr, line_styles.ptr,
361  line_widths.ptr,
362  symbol_colors.ptr, symbol_scales.ptr,
363  symbol_numbers.ptr, symbolsz );
364 }
365 
366 // Draws line segments connecting a series of points.
367 void plline( PLFLT[] x, PLFLT[] y )
368 {
369  PLINT n = cast(PLINT) x.length;
370  assert( n == y.length, "plline(): Arrays must be of same length!" );
371  c_plline( n, x.ptr, y.ptr );
372 }
373 
374 // Draws a line in 3 space.
375 void plline3( PLFLT[] x, PLFLT[] y, PLFLT[] z )
376 {
377  PLINT n = cast(PLINT) x.length;
378  assert( n == y.length, "plline3(): Arrays must be of same length!" );
379  assert( n == z.length, "plline3(): Arrays must be of same length!" );
380  c_plline3( n, x.ptr, y.ptr, z.ptr );
381 }
382 
383 // plot continental outline in world coordinates
384 void plmap( mapform_func mapform, string type, PLFLT minlong, PLFLT maxlong,
385  PLFLT minlat, PLFLT maxlat )
386 {
387  c_plmap( mapform, toStringz( type ), minlong, maxlong, minlat, maxlat );
388 }
389 
390 // Plots a mesh representation of the function z[x][y].
391 void plmesh( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt )
392 {
393  PLINT nx = cast(PLINT) z.length;
394  PLINT ny = cast(PLINT) z[0].length;
395 
396  assert( nx == x.length, "plmesh(): Arrays must be of same length!" );
397  assert( ny == y.length, "plmesh(): Arrays must be of same length!" );
398 
399  c_plmesh( x.ptr, y.ptr, convert_array( z ), nx, ny, opt );
400 }
401 
402 // Plots a mesh representation of the function z[x][y] with contour
403 void plmeshc( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel )
404 {
405  PLINT nx = cast(PLINT) z.length;
406  PLINT ny = cast(PLINT) z[0].length;
407 
408  assert( nx == x.length, "plmeshc(): Arrays must be of same length!" );
409  assert( ny == y.length, "plmeshc(): Arrays must be of same length!" );
410 
411  c_plmeshc( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length );
412 }
413 
414 // Prints out "text" at specified position relative to viewport
415 void plmtex( string side, PLFLT disp, PLFLT pos, PLFLT just, string text )
416 {
417  c_plmtex( toStringz( side ), disp, pos, just, toStringz( text ) );
418 }
419 
420 // Prints out "text" at specified position relative to viewport (3D)
421 void plmtex3( string side, PLFLT disp, PLFLT pos, PLFLT just, string text )
422 {
423  c_plmtex3( toStringz( side ), disp, pos, just, toStringz( text ) );
424 }
425 
426 // Plots a 3-d representation of the function z[x][y].
427 void plot3d( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLBOOL side )
428 {
429  PLINT nx = cast(PLINT) z.length;
430  PLINT ny = cast(PLINT) z[0].length;
431 
432  assert( nx == x.length, "plot3d(): Arrays must be of same length!" );
433  assert( ny == y.length, "plot3d(): Arrays must be of same length!" );
434 
435  c_plot3d( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, side );
436 }
437 
438 // Plots a 3-d representation of the function z[x][y] with contour.
439 void plot3dc( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel )
440 {
441  PLINT nx = cast(PLINT) z.length;
442  PLINT ny = cast(PLINT) z[0].length;
443 
444  assert( nx == x.length, "plot3dc(): Arrays must be of same length!" );
445  assert( ny == y.length, "plot3dc(): Arrays must be of same length!" );
446 
447  c_plot3dc( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length );
448 }
449 
450 // Plots a 3-d representation of the function z[x][y] with contour and
451 // y index limits.
452 void plot3dcl( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel,
453  PLINT ixstart, PLINT ixn, PLINT[] indexymin, PLINT[] indexymax )
454 {
455  PLINT nx = cast(PLINT) z.length;
456  PLINT ny = cast(PLINT) z[0].length;
457 
458  assert( nx == x.length, "plot3dcl(): Arrays must be of same length!" );
459  assert( ny == y.length, "plot3dcl(): Arrays must be of same length!" );
460 
461  c_plot3dcl( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length,
462  ixstart, ixn, indexymin.ptr, indexymax.ptr );
463 }
464 
465 // Set fill pattern directly.
466 void plpat( PLINT[] inc, PLINT[] del )
467 {
468  PLINT nlin = cast(PLINT) inc.length;
469  assert( nlin == del.length, "plpat(): Arrays must be of same length!" );
470  c_plpat( nlin, inc.ptr, del.ptr );
471 }
472 
473 // Plots array y against x for n points using ASCII code "code".
474 void plpoin( PLFLT[] x, PLFLT[] y, PLINT code )
475 {
476  PLINT n = cast(PLINT) x.length;
477  assert( n == y.length, "plpoin(): Arrays must be of same length!" );
478  c_plpoin( n, x.ptr, y.ptr, code );
479 }
480 
481 // Draws a series of points in 3 space.
482 void plpoin3( PLFLT[] x, PLFLT[] y, PLFLT[] z, PLINT code )
483 {
484  PLINT n = cast(PLINT) x.length;
485  assert( n == y.length, "plpoin3(): Arrays must be of same length!" );
486  assert( n == z.length, "plpoin3(): Arrays must be of same length!" );
487  c_plpoin3( n, x.ptr, y.ptr, z.ptr, code );
488 }
489 
490 // Plots array y against x for n points using (UTF-8) text string
491 void plstring( PLFLT[] x, PLFLT[] y, string text )
492 {
493  PLINT n = cast(PLINT) x.length;
494  assert( n == y.length, "plstring(): Arrays must be of same length!" );
495  c_plstring( n, x.ptr, y.ptr, toStringz( text ) );
496 }
497 
498 // Draws a series of points (described by [UTF8] text string) in 3 space.
499 void plstring3( PLFLT[] x, PLFLT[] y, PLFLT[] z, string text )
500 {
501  PLINT n = cast(PLINT) x.length;
502  assert( n == y.length, "plstring3(): Arrays must be of same length!" );
503  assert( n == z.length, "plstring3(): Arrays must be of same length!" );
504  c_plstring3( n, x.ptr, y.ptr, z.ptr, toStringz( text ) );
505 }
506 
507 // Draws a polygon in 3 space.
508 void plpoly3( PLFLT[] x, PLFLT[] y, PLFLT[] z, PLBOOL[] draw, PLBOOL ifcc )
509 {
510  PLINT n = cast(PLINT) x.length;
511  assert( n == y.length, "plpoly3(): Arrays must be of same length!" );
512  assert( n == z.length, "plpoly3(): Arrays must be of same length!" );
513  assert( n - 1 == draw.length, "plpoly3(): Array draw must be of same length then other arrays minus 1!" );
514  c_plpoly3( n, x.ptr, y.ptr, z.ptr, draw.ptr, ifcc );
515 }
516 
517 // Prints out "text" at world cooordinate (x,y).
518 void plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, string text )
519 {
520  c_plptex( x, y, dx, dy, just, toStringz( text ) );
521 }
522 
523 // Prints out "text" at world cooordinate (x,y,z).
524 void plptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz,
525  PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, string text )
526 {
527  c_plptex3( wx, wy, wz, dx, dy, dz, sx, sy, sz, just, toStringz( text ) );
528 }
529 
530 // Set the colors for color table 0 from a cmap0 file
531 void plspal0( string filename )
532 {
533  c_plspal0( toStringz( filename ) );
534 }
535 
536 // Set the colors for color table 1 from a cmap1 file
537 void plspal1( string filename, PLBOOL interpolate )
538 {
539  c_plspal1( toStringz( filename ), interpolate );
540 }
541 
542 // Set color map 0 colors by 8 bit RGB values
543 void plscmap0( PLINT[] r, PLINT[] g, PLINT[] b )
544 {
545  PLINT ncol0 = cast(PLINT) r.length;
546  assert( ncol0 == g.length, "plscmap0(): Arrays must be of same length!" );
547  assert( ncol0 == b.length, "plscmap0(): Arrays must be of same length!" );
548  c_plscmap0( r.ptr, g.ptr, b.ptr, ncol0 );
549 }
550 
551 // Set color map 0 colors by 8 bit RGB values and alpha values
552 void plscmap0a( PLINT[] r, PLINT[] g, PLINT[] b, PLFLT[] a )
553 {
554  PLINT ncol0 = cast(PLINT) r.length;
555  assert( ncol0 == g.length, "plscmap0a(): Arrays must be of same length!" );
556  assert( ncol0 == b.length, "plscmap0a(): Arrays must be of same length!" );
557  assert( ncol0 == a.length, "plscmap0a(): Arrays must be of same length!" );
558  c_plscmap0a( r.ptr, g.ptr, b.ptr, a.ptr, ncol0 );
559 }
560 
561 // Set color map 1 colors by 8 bit RGB values
562 void plscmap1( PLINT[] r, PLINT[] g, PLINT[] b )
563 {
564  PLINT ncol1 = cast(PLINT) r.length;
565  assert( ncol1 == g.length, "plscmap1(): Arrays must be of same length!" );
566  assert( ncol1 == b.length, "plscmap1(): Arrays must be of same length!" );
567  c_plscmap1( r.ptr, g.ptr, b.ptr, ncol1 );
568 }
569 
570 // Set color map 1 colors by 8 bit RGB and alpha values
571 void plscmap1a( PLINT[] r, PLINT[] g, PLINT[] b, PLFLT[] a )
572 {
573  PLINT ncol1 = cast(PLINT) r.length;
574  assert( ncol1 == g.length, "plscmap1a(): Arrays must be of same length!" );
575  assert( ncol1 == b.length, "plscmap1a(): Arrays must be of same length!" );
576  assert( ncol1 == a.length, "plscmap1a(): Arrays must be of same length!" );
577  c_plscmap1a( r.ptr, g.ptr, b.ptr, a.ptr, ncol1 );
578 }
579 
580 // Set color map 1 colors using a piece-wise linear relationship between
581 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
582 void plscmap1l( PLBOOL itype, PLFLT[] intensity, PLFLT[] coord1,
583  PLFLT[] coord2, PLFLT[] coord3, PLBOOL[] alt_hue_path = null )
584 {
585  PLINT npts = cast(PLINT) intensity.length;
586  assert( npts == coord1.length, "plscmap1l(): Arrays must be of same length!" );
587  assert( npts == coord2.length, "plscmap1l(): Arrays must be of same length!" );
588  assert( npts == coord3.length, "plscmap1l(): Arrays must be of same length!" );
589  if ( alt_hue_path != null )
590  {
591  assert( npts - 1 == alt_hue_path.length, "plscmap1l(): Array alt_hue_path must be of same length then other arrays minus 1!" );
592  c_plscmap1l( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, alt_hue_path.ptr );
593  }
594  else
595  c_plscmap1l( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, null );
596 }
597 
598 
599 // Set color map 1 colors using a piece-wise linear relationship between
600 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
601 // Will also linear interpolate alpha values.
602 void plscmap1la( PLBOOL itype, PLFLT[] intensity, PLFLT[] coord1,
603  PLFLT[] coord2, PLFLT[] coord3, PLFLT[] a, PLBOOL[] alt_hue_path = null )
604 {
605  PLINT npts = cast(PLINT) intensity.length;
606  assert( npts == coord1.length, "plscmap1la(): Arrays must be of same length!" );
607  assert( npts == coord2.length, "plscmap1la(): Arrays must be of same length!" );
608  assert( npts == coord3.length, "plscmap1la(): Arrays must be of same length!" );
609  assert( npts == a.length, "plscmap1la(): Arrays must be of same length!" );
610  if ( alt_hue_path != null )
611  {
612  assert( npts - 1 == alt_hue_path.length, "plscmap1la(): Array alt_hue_path must be of same length then other arrays minus 1!" );
613  c_plscmap1la( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, a.ptr, alt_hue_path.ptr );
614  }
615  else
616  c_plscmap1la( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, a.ptr, null );
617 }
618 
619 // Set the device (keyword) name
620 void plsdev( string devname )
621 {
622  c_plsdev( toStringz( devname ) );
623 }
624 
625 // Set the output file name.
626 void plsfnam( string fnam )
627 {
628  c_plsfnam( toStringz( fnam ) );
629 }
630 
631 // Shade region.
632 void plshade( PLFLT[][] a, def_func defined, PLFLT left, PLFLT right,
633  PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap,
634  PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color,
635  PLFLT max_width, PLBOOL rectangular,
636  pltr_func pltr = null, PLPointer pltr_data = null )
637 {
638  PLINT nx = cast(PLINT) a.length;
639  PLINT ny = cast(PLINT) a[0].length;
640 
641  c_plshade( convert_array( a ), nx, ny, defined, left, right, bottom, top, shade_min, shade_max, sh_cmap,
642  sh_color, sh_width, min_color, min_width, max_color, max_width, &c_plfill,
643  rectangular, pltr, pltr_data );
644 }
645 
646 void plshades( PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
647  PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width,
648  PLBOOL rectangular, pltr_func pltr = null, PLPointer pltr_data = null )
649 {
650  PLINT nx = cast(PLINT) a.length;
651  PLINT ny = cast(PLINT) a[0].length;
652 
653  c_plshades( convert_array( a ), nx, ny, defined, xmin, xmax, ymin, ymax, clevel.ptr, cast(PLINT) clevel.length,
654  fill_width, cont_color, cont_width, &c_plfill, rectangular, pltr, pltr_data );
655 }
656 
657 void plshades( PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
658  PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width,
659  PLBOOL rectangular, ref PLcGrid cgrid )
660 {
661  PLINT nx = cast(PLINT) a.length;
662  PLINT ny = cast(PLINT) a[0].length;
663 
664  c_PLcGrid c;
665  c.xg = cgrid.xg.ptr;
666  c.nx = cast(PLINT) cgrid.xg.length;
667  c.yg = cgrid.yg.ptr;
668  c.ny = cast(PLINT) cgrid.yg.length;
669  c.zg = cgrid.zg.ptr;
670  c.nz = cast(PLINT) cgrid.zg.length;
671 
672  c_plshades( convert_array( a ), nx, ny, defined, xmin, xmax, ymin, ymax, clevel.ptr, cast(PLINT) clevel.length,
673  fill_width, cont_color, cont_width, &c_plfill, rectangular, &pltr1, &c );
674 }
675 
676 void plshades( PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
677  PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width,
678  PLBOOL rectangular, ref PLcGrid2 cgrid2 )
679 {
680  PLINT nx = cast(PLINT) a.length;
681  PLINT ny = cast(PLINT) a[0].length;
682 
683  c_PLcGrid2 c2;
684  c2.xg = convert_array( cgrid2.xg );
685  c2.yg = convert_array( cgrid2.yg );
686  c2.zg = convert_array( cgrid2.zg );
687  c2.nx = cast(PLINT) cgrid2.xg.length;
688  c2.ny = cast(PLINT) cgrid2.xg[0].length;
689  if ( cgrid2.yg )
690  {
691  assert( c2.nx == cgrid2.yg.length, "plcont(): Arrays must be of same length!" );
692  assert( c2.ny == cgrid2.yg[0].length, "plcont(): Arrays must be of same length!" );
693  }
694  if ( cgrid2.zg )
695  {
696  assert( c2.nx == cgrid2.zg.length, "plcont(): Arrays must be of same length!" );
697  assert( c2.ny == cgrid2.zg[0].length, "plcont(): Arrays must be of same length!" );
698  }
699 
700  c_plshades( convert_array( a ), nx, ny, defined, xmin, xmax, ymin, ymax, clevel.ptr, cast(PLINT) clevel.length,
701  fill_width, cont_color, cont_width, &c_plfill, rectangular, &pltr2, &c2 );
702 }
703 
704 // Initialize PLplot, passing the device name and windows/page settings.
705 void plstart( string devname, PLINT nx, PLINT ny )
706 {
707  c_plstart( toStringz( devname ), nx, ny );
708 }
709 
710 // Create 1d stripchart
711 void plstripc( PLINT* id, string xspec, string yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump,
712  PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc,
713  PLINT colbox, PLINT collab, PLINT[] colline, PLINT[] styline, string[] legline,
714  string labx, string laby, string labtop )
715 {
716  assert( 4 == colline.length, "plstripc(): Arrays must be of length 4!" );
717  assert( 4 == styline.length, "plstripc(): Arrays must be of length 4!" );
718  assert( 4 == legline.length, "plstripc(): Arrays must be of length 4!" );
719 
720  immutable( char ) * *leglinez = array( map!toStringz( legline ) ).ptr;
721  //for ( int i = 0; i < 4; i++ )
722  //{
723  // leglinez[i] = toStringz( legline[i] );
724  //}
725 
726  c_plstripc( id, toStringz( xspec ), toStringz( yspec ), xmin, xmax, xjump, ymin, ymax,
727  xlpos, ylpos, y_ascl, acc, colbox, collab, colline.ptr, styline.ptr, leglinez,
728  toStringz( labx ), toStringz( laby ), toStringz( labtop ) );
729 }
730 
731 // plots a 2d image (or a matrix too large for plshade() )
733  PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax,
734  pltr_func pltr = null, PLPointer pltr_data = null )
735 {
736  PLINT nx = cast(PLINT) idata.length;
737  PLINT ny = cast(PLINT) idata[0].length;
738 
739  c_plimagefr( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
740  valuemin, valuemax, pltr, pltr_data );
741 }
742 
743 // plots a 2d image (or a matrix too large for plshade() )
745  PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLcGrid cgrid )
746 {
747  PLINT nx = cast(PLINT) idata.length;
748  PLINT ny = cast(PLINT) idata[0].length;
749 
750  c_PLcGrid c;
751  c.xg = cgrid.xg.ptr;
752  c.nx = cast(PLINT) cgrid.xg.length;
753  c.yg = cgrid.yg.ptr;
754  c.ny = cast(PLINT) cgrid.yg.length;
755  c.zg = cgrid.zg.ptr;
756  c.nz = cast(PLINT) cgrid.zg.length;
757 
758  c_plimagefr( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
759  valuemin, valuemax, &pltr1, &c );
760 }
761 
762 // plots a 2d image (or a matrix too large for plshade() )
764  PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLcGrid2 cgrid2 )
765 {
766  PLINT nx = cast(PLINT) idata.length;
767  PLINT ny = cast(PLINT) idata[0].length;
768 
769  c_PLcGrid2 c2;
770  c2.xg = convert_array( cgrid2.xg );
771  c2.yg = convert_array( cgrid2.yg );
772  c2.zg = convert_array( cgrid2.zg );
773  c2.nx = cast(PLINT) cgrid2.xg.length;
774  c2.ny = cast(PLINT) cgrid2.xg[0].length;
775  if ( cgrid2.yg )
776  {
777  assert( c2.nx == cgrid2.yg.length, "plcont(): Arrays must be of same length!" );
778  assert( c2.ny == cgrid2.yg[0].length, "plcont(): Arrays must be of same length!" );
779  }
780  if ( cgrid2.zg )
781  {
782  assert( c2.nx == cgrid2.zg.length, "plcont(): Arrays must be of same length!" );
783  assert( c2.ny == cgrid2.zg[0].length, "plcont(): Arrays must be of same length!" );
784  }
785 
786  c_plimagefr( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
787  valuemin, valuemax, &pltr2, &c2 );
788 }
789 
790 // plots a 2d image (or a matrix too large for plshade() ) - colors
791 // automatically scaled
793  PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax )
794 {
795  PLINT nx = cast(PLINT) idata.length;
796  PLINT ny = cast(PLINT) idata[0].length;
797 
798  c_plimage( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax,
799  Dymin, Dymax );
800 }
801 
802 // Set up a new line style
803 void plstyl( PLINT[] mark, PLINT[] space )
804 {
805  PLINT nms = cast(PLINT) mark.length;
806  assert( nms == space.length, "plstyl(): Arrays must be of same length!" );
807  c_plstyl( nms, mark.ptr, space.ptr );
808 }
809 
810 // Plots the 3d surface representation of the function z[x][y].
811 void plsurf3d( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel = null )
812 {
813  PLINT nx = cast(PLINT) z.length;
814  PLINT ny = cast(PLINT) z[0].length;
815  assert( nx == x.length, "plsurf3d(): Arrays must be of same length!" );
816  assert( ny == y.length, "plsurf3d(): Arrays must be of same length!" );
817 
818  if ( clevel )
819  c_plsurf3d( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length );
820  else
821  c_plsurf3d( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, null, 0 );
822 }
823 
824 // Plots the 3d surface representation of the function z[x][y] with y
825 // index limits.
826 void plsurf3dl( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel,
827  PLINT ixstart, PLINT ixn, PLINT[] indexymin, PLINT[] indexymax )
828 {
829  PLINT nx = cast(PLINT) z.length;
830  PLINT ny = cast(PLINT) z[0].length;
831  assert( nx == x.length, "plsurf3d(): Arrays must be of same length!" );
832  assert( ny == y.length, "plsurf3d(): Arrays must be of same length!" );
833 
834  c_plsurf3dl( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length,
835  ixstart, ixn, indexymin.ptr, indexymax.ptr );
836 }
837 
838 // Plots array y against x for n points using Hershey symbol "code"
839 void plsym( PLFLT[] x, PLFLT[] y, PLINT code )
840 {
841  PLINT n = cast(PLINT) x.length;
842  assert( n == y.length, "plsym(): Arrays must be of same length!" );
843  c_plsym( n, x.ptr, y.ptr, code );
844 }
845 
846 // Set the format for date / time labels
847 void pltimefmt( string fmt )
848 {
849  c_pltimefmt( toStringz( fmt ) );
850 }
851 
852 //--------------------------------------------------------------------------
853 // Functions for use from C or C++ only
854 //--------------------------------------------------------------------------
855 
856 // Returns a list of file-oriented device names and their menu strings
857 //void plgFileDevs(char ***p_menustr, char ***p_devname, int *p_ndev);
858 
859 // Returns a list of all device names and their menu strings
860 //void plgDevs(char ***p_menustr, char ***p_devname, int *p_ndev);
861 
862 // Set the function pointer for the keyboard event handler
863 //void plsKeyEH(void function(PLGraphicsIn *, void *, int *)KeyEH, void *KeyEH_data);
864 
865 // Set the function pointer for the (mouse) button event handler
866 //void plsButtonEH(void function(PLGraphicsIn *, void *, int *)ButtonEH, void *ButtonEH_data);
867 
868 // Sets an optional user bop handler
869 //void plsbopH(void function(void *, int *)handler, void *handler_data);
870 
871 // Sets an optional user eop handler
872 //void plseopH(void function(void *, int *)handler, void *handler_data);
873 
874 // Set the variables to be used for storing error info
875 //void plsError(PLINT *errcode, char *errmsg)
876 //{
877 //}
878 
879 // Sets an optional user exit handler.
880 //void plsexit(int function(char *)handler);
881 
882 // Sets an optional user abort handler.
883 //void plsabort(void function(char *)handler);
884 
885 // Function evaluators
886 
887 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
888 // and is column dominant (normal C ordering).
889 //PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data);
890 
891 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
892 // and is column dominant (normal C ordering).
893 //PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data);
894 
895 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
896 // and is row dominant (Fortran ordering).
897 //PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data);
898 
899 // Command line parsing utilities
900 
901 // Merge user option table into internal info structure.
902 //int plMergeOpts(PLOptionTable *options, char *name, char **notes);
903 
904 // Set the strings used in usage and syntax messages.
905 //void plSetUsage(char *program_string, char *usage_string);
906 
907 // Process input strings, treating them as an option and argument pair.
908 // The first is for the external API, the second the work routine declared
909 // here for backward compatibilty.
910 int plsetopt( string opt, string optarg )
911 {
912  return c_plsetopt( toStringz( opt ), toStringz( optarg ) );
913 }
914 
915 // Miscellaneous
916 
917 // Get the escape character for text strings.
918 //void plgesc(char *p_esc);
919 
920 // Front-end to driver escape function.
921 //void pl_cmd(PLINT op, void *ptr);
922 
923 // Return full pathname for given file if executable
924 //int plFindName(char *p);
925 
926 // Looks for the specified executable file according to usual search path.
927 //char * plFindCommand(char *fn);
928 
929 // Gets search name for file by concatenating the dir, subdir, and file
930 // name, allocating memory as needed.
931 //void plGetName(char *dir, char *subdir, char *filename, char **filespec);
932 
933 // Prompts human to input an integer in response to given message.
934 //PLINT plGetInt(char *s);
935 
936 // Prompts human to input a float in response to given message.
937 //PLFLT plGetFlt(char *s);
938 
939 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
940 void plMinMax2dGrid( PLFLT[][] f, out PLFLT fmax, out PLFLT fmin )
941 {
942  plMinMax2dGrid( convert_array( f ), cast(PLINT) f.length, cast(PLINT) f[0].length, &fmax, &fmin );
943 }
944 
945 // Wait for graphics input event and translate to world coordinates
946 //int plGetCursor(PLGraphicsIn *gin);
947 
948 // Translates relative device coordinates to world coordinates.
949 //int plTranslateCursor(PLGraphicsIn *gin);
950 
951 
952 
953 extern ( C ) :
954 
955 alias double PLFLT;
956 
957 // This is apparently portable if stdint.h exists.
958 // A reasonable back-up in case stdint.h does not exist on the platform.
959 alias uint PLUNICODE;
960 alias int PLINT;
961 
962 // For identifying logical (boolean) arguments
963 alias PLINT PLBOOL;
964 
965 // For passing user data, as with X's XtPointer
966 alias void* PLPointer;
967 
968 //--------------------------------------------------------------------------
969 // Complex data types and other good stuff
970 //--------------------------------------------------------------------------
971 
972 // Switches for escape function call.
973 // Some of these are obsolete but are retained in order to process
974 // old metafiles.
975 
976 const PLESC_SET_RGB = 1;
978 const PLESC_SET_LPB = 3;
979 const PLESC_EXPOSE = 4;
980 const PLESC_RESIZE = 5;
981 const PLESC_REDRAW = 6;
982 const PLESC_TEXT = 7;
983 const PLESC_GRAPH = 8;
984 const PLESC_FILL = 9;
985 const PLESC_DI = 10;
986 const PLESC_FLUSH = 11;
987 const PLESC_EH = 12;
988 const PLESC_GETC = 13;
989 const PLESC_SWIN = 14;
991 const PLESC_XORMOD = 16;
993 const PLESC_CLEAR = 18;
994 const PLESC_DASH = 19;
995 const PLESC_HAS_TEXT = 20;
996 const PLESC_IMAGE = 21;
997 const PLESC_IMAGEOPS = 22;
998 const PLESC_PL2DEVCOL = 23;
999 const PLESC_DEV2PLCOL = 24;
1000 const PLESC_SETBGFG = 25;
1001 const PLESC_DEVINIT = 26;
1002 
1003 // image operations
1004 const ZEROW2B = 1;
1005 const ZEROW2D = 2;
1006 const ONEW2B = 3;
1007 const ONEW2D = 4;
1008 
1009 // Window parameter tags
1010 const PLSWIN_DEVICE = 1;
1011 const PLSWIN_WORLD = 2;
1012 
1013 // Axis label tags
1014 const PL_X_AXIS = 1; // The x-axis
1015 const PL_Y_AXIS = 2; // The y-axis
1016 const PL_Z_AXIS = 3; // The z-axis
1017 
1018 // PLplot Option table & support constants
1019 
1020 // Option-specific settings
1021 const PL_OPT_ENABLED = 0x0001;
1022 const PL_OPT_ARG = 0x0002;
1023 const PL_OPT_NODELETE = 0x0004;
1024 const PL_OPT_INVISIBLE = 0x0008;
1025 const PL_OPT_DISABLED = 0x0010;
1026 
1027 // Option-processing settings -- mutually exclusive
1028 const PL_OPT_FUNC = 0x0100;
1029 const PL_OPT_BOOL = 0x0200;
1030 const PL_OPT_INT = 0x0400;
1031 const PL_OPT_FLOAT = 0x0800;
1032 const PL_OPT_STRING = 0x1000;
1033 
1034 // Global mode settings
1035 // These override per-option settings
1036 const PL_PARSE_PARTIAL = 0x0000;
1037 const PL_PARSE_FULL = 0x0001;
1038 const PL_PARSE_QUIET = 0x0002;
1039 
1040 // processing
1041 const PL_PARSE_NODELETE = 0x0004;
1042 const PL_PARSE_SHOWALL = 0x0008;
1043 const PL_PARSE_OVERRIDE = 0x0010;
1044 const PL_PARSE_NOPROGRAM = 0x0020;
1045 const PL_PARSE_NODASH = 0x0040;
1046 const PL_PARSE_SKIP = 0x0080;
1047 
1048 // FCI (font characterization integer) related constants.
1049 const PL_FCI_MARK = 0x80000000;
1050 const PL_FCI_IMPOSSIBLE = 0x00000000;
1053 
1054 // These define hexpower values corresponding to each font attribute.
1056 const PL_FCI_FAMILY = 0x0;
1057 const PL_FCI_STYLE = 0x1;
1058 
1059 // These are legal values for font family attribute
1060 const PL_FCI_WEIGHT = 0x2;
1061 const PL_FCI_SANS = 0x0;
1062 const PL_FCI_SERIF = 0x1;
1063 const PL_FCI_MONO = 0x2;
1064 const PL_FCI_SCRIPT = 0x3;
1065 
1066 // These are legal values for font style attribute
1067 const PL_FCI_SYMBOL = 0x4;
1068 const PL_FCI_UPRIGHT = 0x0;
1069 const PL_FCI_ITALIC = 0x1;
1070 
1071 // These are legal values for font weight attribute
1072 const PL_FCI_MEDIUM = 0x0;
1073 const PL_FCI_BOLD = 0x1;
1074 const PL_FCI_OBLIQUE = 0x2;
1075 
1076 // Obsolete names
1077 
1078 // Option table definition
1079 
1080 struct _N1
1081 {
1082  string opt;
1083  int function( char *, char *, void * ) handler;
1085  void *var;
1086  int mode;
1087  string syntax;
1088  string desc;
1089 }
1090 alias _N1 PLOptionTable;
1091 
1092 // PLplot Graphics Input structure
1093 
1094 
1095 const PL_MAXKEY = 16;
1096 struct _N2
1097 {
1098  int type;
1099  uint state;
1100  uint keysym;
1101  uint button;
1103  char [16] string;
1104  int pX;
1105  int pY;
1110 }
1111 alias _N2 PLGraphicsIn;
1112 
1113 // Structure for describing the plot window
1114 
1115 
1116 const PL_MAXWINDOWS = 64;
1117 struct _N3
1118 {
1127 }
1128 alias _N3 PLWindow;
1129 
1130 // Structure for doing display-oriented operations via escape commands
1131 // May add other attributes in time
1132 
1133 struct _N4
1134 {
1135  uint x;
1136  uint y;
1137  uint width;
1138  uint height;
1139 }
1140 alias _N4 PLDisplay;
1141 
1142 // Macro used (in some cases) to ignore value of argument
1143 // I don't plan on changing the value so you can hard-code it
1144 
1145 const int PL_NOTSET = -42;
1146 
1147 // See plcont.c for examples of the following
1148 
1149 //
1150 // PLfGrid is for passing (as a pointer to the first element) an arbitrarily
1151 // dimensioned array. The grid dimensions MUST be stored, with a maximum of 3
1152 // dimensions assumed for now.
1153 //
1154 
1155 struct _N5
1156 {
1161 }
1162 alias _N5 PLfGrid;
1163 
1164 //
1165 // PLfGrid2 is for passing (as an array of pointers) a 2d function array. The
1166 // grid dimensions are passed for possible bounds checking.
1167 //
1168 
1169 struct _N6
1170 {
1174 }
1175 alias _N6 PLfGrid2;
1176 
1177 //
1178 // NOTE: a PLfGrid3 is a good idea here but there is no way to exploit it yet
1179 // so I'll leave it out for now.
1180 //
1181 
1182 //
1183 // PLcGrid is for passing (as a pointer to the first element) arbitrarily
1184 // dimensioned coordinate transformation arrays. The grid dimensions MUST be
1185 // stored, with a maximum of 3 dimensions assumed for now.
1186 //
1187 
1188 struct _N7
1189 {
1196 }
1197 alias _N7 c_PLcGrid;
1198 
1199 //
1200 // PLcGrid2 is for passing (as arrays of pointers) 2d coordinate
1201 // transformation arrays. The grid dimensions are passed for possible bounds
1202 // checking.
1203 //
1204 
1205 struct _N8
1206 {
1212 }
1213 alias _N8 c_PLcGrid2;
1214 
1215 //
1216 // NOTE: a PLcGrid3 is a good idea here but there is no way to exploit it yet
1217 // so I'll leave it out for now.
1218 //
1219 
1220 // PLColor is the usual way to pass an rgb color value.
1221 
1222 struct _N9
1223 {
1224  ubyte r;
1225  ubyte g;
1226  ubyte b;
1228  char *name;
1229 }
1230 alias _N9 PLColor;
1231 
1232 // PLControlPt is how cmap1 control points are represented.
1233 
1234 struct _N10
1235 {
1242 }
1243 alias _N10 PLControlPt;
1244 
1245 // A PLBufferingCB is a control block for interacting with devices
1246 // that support double buffering.
1247 
1248 struct _N11
1249 {
1252 }
1253 alias _N11 PLBufferingCB;
1254 
1257 
1259 
1260 //--------------------------------------------------------------------------* * BRAINDEAD-ness
1261 //
1262 // Some systems allow the Fortran & C namespaces to clobber each other.
1263 // For PLplot to work from Fortran on these systems, we must name the the
1264 // externally callable C functions something other than their Fortran entry
1265 // names. In order to make this as easy as possible for the casual user,
1266 // yet reversible to those who abhor my solution, I have done the
1267 // following:
1268 //
1269 // The C-language bindings are actually different from those
1270 // described in the manual. Macros are used to convert the
1271 // documented names to the names used in this package. The
1272 // user MUST include plplot.h in order to get the name
1273 // redefinition correct.
1274 //
1275 // Sorry to have to resort to such an ugly kludge, but it is really the
1276 // best way to handle the situation at present. If all available
1277 // compilers offer a way to correct this stupidity, then perhaps we can
1278 // eventually reverse it.
1279 //
1280 // If you feel like screaming at someone (I sure do), please
1281 // direct it at your nearest system vendor who has a braindead shared
1282 // C/Fortran namespace. Some vendors do offer compiler switches that
1283 // change the object names, but then everybody who wants to use the
1284 // package must throw these same switches, leading to no end of trouble.
1285 //
1286 // Note that this definition should not cause any noticable effects except
1287 // when debugging PLplot calls, in which case you will need to remember
1288 // the real function names (same as before but with a 'c_' prepended).
1289 //
1290 // Also, to avoid macro conflicts, the BRAINDEAD part must not be expanded
1291 // in the stub routines.
1292 //
1293 // Aside: the reason why a shared Fortran/C namespace is deserving of the
1294 // BRAINDEAD characterization is that it completely precludes the the kind
1295 // of universal API that is attempted (more or less) with PLplot, without
1296 // Herculean efforts (e.g. remapping all of the C bindings by macros as
1297 // done here). The vendors of such a scheme, in order to allow a SINGLE
1298 // type of argument to be passed transparently between C and Fortran,
1299 // namely, a pointer to a conformable data type, have slammed the door on
1300 // insertion of stub routines to handle the conversions needed for other
1301 // data types. Intelligent linkers could solve this problem, but these are
1302 // not anywhere close to becoming universal. So meanwhile, one must live
1303 // with either stub routines for the inevitable data conversions, or a
1304 // different API. The former is what is used here, but is made far more
1305 // difficult in a braindead shared Fortran/C namespace.
1306 //--------------------------------------------------------------------------
1307 
1308 
1309 
1310 
1314 //alias c_plaxes plaxes;
1315 //alias c_plbin plbin;
1317 //alias c_plbox plbox;
1318 //alias c_plbox3 plbox3;
1327 //alias c_plcont plcont;
1335 //alias c_plerrx plerrx;
1336 //alias c_plerry plerry;
1338 //alias c_plfill plfill;
1339 //alias c_plfill3 plfill3;
1349 //alias c_plgdev plgdev;
1355 //alias c_plgfnam plgfnam;
1361 //alias c_plgriddata plgriddata;
1364 //alias c_plgver plgver;
1370 //alias c_plhist plhist;
1373 //alias c_plimage plimage;
1374 //alias c_plimagefr plimagefr;
1377 //alias c_pllab pllab;
1378 //alias c_pllegend pllegend;
1380 //alias c_plline plline;
1381 //alias c_plline3 plline3;
1383 //alias c_plmap plmap;
1385 //alias c_plmesh plmesh;
1386 //alias c_plmeshc plmeshc;
1388 //alias c_plmtex plmtex;
1389 //alias c_plmtex3 plmtex3;
1390 //alias c_plot3d plot3d;
1391 //alias c_plot3dc plot3dc;
1392 //alias c_plot3dcl plot3dcl;
1393 //alias c_plparseopts plparseopts;
1394 //alias c_plpat plpat;
1395 //alias c_plpoin plpoin;
1396 //alias c_plpoin3 plpoin3;
1397 //alias c_plpoly3 plpoly3;
1400 //alias c_plptex plptex;
1401 //alias c_plptex3 plptex3;
1408 //alias c_plscmap0 plscmap0;
1409 //alias c_plscmap0a plscmap0a;
1411 //alias c_plscmap1 plscmap1;
1412 //alias c_plscmap1a plscmap1a;
1413 //alias c_plscmap1l plscmap1l;
1414 //alias c_plscmap1la plscmap1la;
1422 // alias c_plsdev plsdev;
1430 //alias c_plsetopt plsetopt;
1433 // alias c_plsfnam plsfnam;
1435 //alias c_plshade plshade;
1436 //alias c_plshades plshades;
1442 // alias c_plspal0 plspal0;
1443 // alias c_plspal1 plspal1;
1449 //alias c_plstart plstart;
1452 //alias c_plstripc plstripc;
1454 //alias c_plstring plstring;
1455 //alias c_plstring3 plstring3;
1456 //alias c_plstyl plstyl;
1457 //alias c_plsurf3d plsurf3d;
1458 //alias c_plsurf3dl plsurf3dl;
1459 //alias c_plsvect plsvect;
1463 //alias c_plsym plsym;
1466 //alias c_pltimefmt pltimefmt;
1468 //alias c_plvect plvect;
1475 
1477 
1478 
1479 // Redefine some old function names for backward compatibility
1480 
1481 
1482 alias pleop plclr;
1491 
1492 
1493 //--------------------------------------------------------------------------* * Function Prototypes
1494 //--------------------------------------------------------------------------
1495 
1496 
1497 // All void types
1498 // C routines callable from stub routines come first
1499 
1500 // set the format of the contour labels
1501 void c_pl_setcontlabelformat( PLINT lexp, PLINT sigdig );
1502 
1503 // set offset and spacing of contour labels
1504 void c_pl_setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing, PLINT active );
1505 
1506 // Advance to subpage "page", or to the next one if "page" = 0.
1507 void c_pladv( PLINT page );
1508 
1509 // simple arrow plotter.
1510 void c_plvect( PLFLT **u, PLFLT **v, PLINT nx, PLINT ny, PLFLT scale,
1511  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1512 void c_plsvect( PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill );
1513 
1514 // This functions similarly to plbox() except that the origin of the axes
1515 // is placed at the user-specified point (x0, y0).
1516 void c_plaxes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
1517  const char *yopt, PLFLT ytick, PLINT nysub );
1518 
1519 // Flags for plbin() - opt argument
1520 const PL_BIN_DEFAULT = 0;
1521 const PL_BIN_CENTRED = 1;
1523 const PL_BIN_NOEMPTY = 4;
1524 
1525 // Plot a histogram using x to store data values and y to store frequencies
1526 void c_plbin( PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt );
1527 
1528 // Start new page. Should only be used with pleop().
1529 void c_plbop();
1530 
1531 // This draws a box around the current viewport.
1532 void c_plbox( const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub );
1533 
1534 // This is the 3-d analogue of plbox().
1535 void c_plbox3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx, const char *yopt,
1536  const char *ylabel, PLFLT ytick, PLINT nsuby, const char *zopt, const char *zlabel,
1537  PLFLT ztick, PLINT nsubz );
1538 
1539 // Calculate broken-down time from continuous time for current stream.
1540 void c_plbtime( PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime );
1541 
1542 // Setup a user-provided custom labeling function
1543 void c_plslabelfunc( void function( PLINT, PLFLT, char*, PLINT, PLPointer ) labelfunc,
1544  PLPointer label_data );
1545 
1546 // Calculate world coordinates and subpage from relative device coordinates.
1547 void c_plcalc_world( PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window );
1548 
1549 // Plot an arc
1550 void c_plarc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
1551  PLFLT rotate, PLBOOL fill );
1552 
1553 // Clear current subpage.
1554 void c_plclear();
1555 
1556 // Set color, map 0. Argument is integer between 0 and 15.
1557 void c_plcol0( PLINT icol0 );
1558 
1559 // Set color, map 1. Argument is a float between 0. and 1.
1560 void c_plcol1( PLFLT col1 );
1561 
1562 // Configure transformation between continuous and broken-down time (and
1563 // vice versa) for current stream.
1564 void c_plconfigtime( PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset,
1565  PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec );
1566 
1567 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
1568 // plfcont, with a particular choice for f2eval and f2eval_data.
1569 //
1570 void c_plcont( PLFLT **f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly,
1571  PLFLT *clevel, PLINT nlevel,
1572  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1573 
1574 // Draws a contour plot using the function evaluator f2eval and data stored
1575 // by way of the f2eval_data pointer. This allows arbitrary organizations
1576 // of 2d array data to be used.
1577 //
1578 void plfcont( PLFLT function( PLINT, PLINT, PLPointer ) f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny,
1579  PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel,
1580  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1581 
1582 // Copies state parameters from the reference stream to the current stream.
1583 void c_plcpstrm( PLINT iplsr, PLBOOL flags );
1584 
1585 // Calculate continuous time from broken-down time for current stream.
1586 void c_plctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime );
1587 
1588 // Converts input values from relative device coordinates to relative plot
1589 // coordinates.
1590 void pldid2pc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
1591 
1592 // Converts input values from relative plot coordinates to relative
1593 // device coordinates.
1594 void pldip2dc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
1595 
1596 // End a plotting session for all open streams.
1597 void c_plend();
1598 
1599 // End a plotting session for the current stream only.
1600 void c_plend1();
1601 
1602 // Simple interface for defining viewport and window.
1603 void c_plenv( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis );
1604 
1605 // similar to plenv() above, but in multiplot mode does not advance the subpage,
1606 // instead the current subpage is cleared
1607 void c_plenv0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis );
1608 
1609 // End current page. Should only be used with plbop().
1610 void c_pleop();
1611 
1612 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))
1613 void c_plerrx( PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y );
1614 
1615 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))
1616 void c_plerry( PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax );
1617 
1618 // Advance to the next family file on the next new page
1619 void c_plfamadv();
1620 
1621 // Pattern fills the polygon bounded by the input points.
1622 void c_plfill( PLINT n, PLFLT *x, PLFLT *y );
1623 
1624 // Pattern fills the 3d polygon bounded by the input points.
1625 void c_plfill3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z );
1626 
1627 // Flushes the output stream. Use sparingly, if at all.
1628 void c_plflush();
1629 
1630 // Sets the global font flag to 'ifont'.
1631 void c_plfont( PLINT ifont );
1632 
1633 // Load specified font set.
1634 void c_plfontld( PLINT fnt );
1635 
1636 // Get character default height and current (scaled) height
1637 void c_plgchr( PLFLT *p_def, PLFLT *p_ht );
1638 
1639 // Returns 8 bit RGB values for given color from color map 0
1640 void c_plgcol0( PLINT icol0, PLINT *r, PLINT *g, PLINT *b );
1641 
1642 // Returns 8 bit RGB values for given color from color map 0 and alpha value
1643 void c_plgcol0a( PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
1644 
1645 // Returns the background color by 8 bit RGB value
1646 void c_plgcolbg( PLINT *r, PLINT *g, PLINT *b );
1647 
1648 // Returns the background color by 8 bit RGB value and alpha value
1649 void c_plgcolbga( PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
1650 
1651 // Returns the current compression setting
1652 void c_plgcompression( PLINT *compression );
1653 
1654 // Get the current device (keyword) name
1655 void c_plgdev( char *p_dev );
1656 
1657 // Retrieve current window into device space
1658 void c_plgdidev( PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy );
1659 
1660 // Get plot orientation
1661 void c_plgdiori( PLFLT *p_rot );
1662 
1663 // Retrieve current window into plot space
1664 void c_plgdiplt( PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax );
1665 
1666 // Get FCI (font characterization integer)
1667 
1668 void c_plgfci( PLUNICODE *pfci );
1669 
1670 // Get family file parameters
1671 
1672 void c_plgfam( PLINT *p_fam, PLINT *p_num, PLINT *p_bmax );
1673 
1674 // Get the (current) output file name. Must be preallocated to >80 bytes
1675 void c_plgfnam( char *fnam );
1676 
1677 // Get the current font family, style and weight
1678 void c_plgfont( PLINT *p_family, PLINT *p_style, PLINT *p_weight );
1679 
1680 // Get the (current) run level.
1681 void c_plglevel( PLINT *p_level );
1682 
1683 // Get output device parameters.
1684 void c_plgpage( PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng,
1685  PLINT *p_xoff, PLINT *p_yoff );
1686 
1687 // Switches to graphics screen.
1688 void c_plgra();
1689 
1690 // Draw gradient in polygon.
1691 void c_plgradient( PLINT n, PLFLT *x, PLFLT *y, PLFLT angle );
1692 
1693 // grid irregularly sampled data
1694 void c_plgriddata( PLFLT *x, PLFLT *y, PLFLT *z, PLINT npts, PLFLT *xg, PLINT nptsx,
1695  PLFLT *yg, PLINT nptsy, PLFLT **zg, PLINT type, PLFLT data );
1696 
1697 // type of gridding algorithm for plgriddata()
1698 const GRID_CSA = 1;
1699 const GRID_DTLI = 2;
1700 const GRID_NNI = 3;
1701 const GRID_NNIDW = 4;
1702 const GRID_NNLI = 5;
1703 const GRID_NNAIDW = 6;
1704 
1705 // Get subpage boundaries in absolute coordinates
1706 void c_plgspa( PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax );
1707 
1708 // Get current stream number.
1709 void c_plgstrm( PLINT *p_strm );
1710 
1711 // Get the current library version number
1712 void c_plgver( char *p_ver );
1713 
1714 // Get viewport boundaries in normalized device coordinates
1715 void c_plgvpd( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
1716 
1717 // Get viewport boundaries in world coordinates
1718 void c_plgvpw( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
1719 
1720 // Get x axis labeling parameters
1721 void c_plgxax( PLINT *p_digmax, PLINT *p_digits );
1722 
1723 // Get y axis labeling parameters
1724 void c_plgyax( PLINT *p_digmax, PLINT *p_digits );
1725 
1726 // Get z axis labeling parameters
1727 void c_plgzax( PLINT *p_digmax, PLINT *p_digits );
1728 
1729 // Flags for plhist() - opt argument; note: some flags are passed to
1730 // plbin() for the actual plotting
1735 const PL_HIST_NOEMPTY = 16;
1736 
1737 // Draws a histogram of n values of a variable in array data[0..n-1]
1738 void c_plhist( PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt );
1739 
1740 // Set current color (map 0) by hue, lightness, and saturation.
1741 void c_plhls( PLFLT h, PLFLT l, PLFLT s );
1742 
1743 // Functions for converting between HLS and RGB color space
1744 void c_plhlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
1745 
1746 // Initializes PLplot, using preset or default options
1747 void c_plinit();
1748 
1749 // Draws a line segment from (x1, y1) to (x2, y2).
1750 void c_pljoin( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
1751 
1752 // Simple routine for labelling graphs.
1753 void c_pllab( const char *xlabel, const char *ylabel, const char *tlabel );
1754 
1755 // Flags used for position argument of both pllegend and plcolorbar
1764 
1765 // Flags for pllegend
1766 const PL_LEGEND_NONE = 1;
1768 const PL_LEGEND_LINE = 4;
1774 
1775 // Flags for plcolorbar
1786 
1787 // Routine for drawing discrete line, symbol, or cmap0 legends
1788 void c_pllegend( PLFLT *p_legend_width, PLFLT *p_legend_height,
1789  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
1791  PLINT nrow, PLINT ncolumn,
1792  PLINT nlegend, PLINT *opt_array,
1793  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
1794  PLFLT text_justification,
1795  PLINT *text_colors, const char **text,
1796  PLINT *box_colors, PLINT *box_patterns,
1797  PLFLT *box_scales, PLFLT *box_line_widths,
1798  PLINT *line_colors, PLINT *line_styles,
1799  PLFLT *line_widths,
1800  PLINT *symbol_colors, PLFLT *symbol_scales,
1801  PLINT *symbol_numbers, const char **symbols );
1802 
1803 // Sets position of the light source
1804 void c_pllightsource( PLFLT x, PLFLT y, PLFLT z );
1805 
1806 // Draws line segments connecting a series of points.
1807 void c_plline( PLINT n, PLFLT *x, PLFLT *y );
1808 
1809 // Draws a line in 3 space.
1810 void c_plline3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z );
1811 
1812 // Set line style.
1813 void c_pllsty( PLINT lin );
1814 
1815 // plot continental outline in world coordinates
1816 void c_plmap( void function( PLINT, PLFLT *, PLFLT* ) mapform, const char *type, PLFLT minlong,
1817  PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
1818 
1819 // Plot the latitudes and longitudes on the background.
1820 void c_plmeridians( void function( PLINT, PLFLT *, PLFLT* ) mapform, PLFLT dlong, PLFLT dlat,
1821  PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
1822 
1823 // Plots a mesh representation of the function z[x][y].
1824 void c_plmesh( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt );
1825 
1826 // Plots a mesh representation of the function z[x][y] with contour
1827 void c_plmeshc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1828  PLFLT *clevel, PLINT nlevel );
1829 
1830 // Creates a new stream and makes it the default.
1831 void c_plmkstrm( PLINT *p_strm );
1832 
1833 // Prints out "text" at specified position relative to viewport
1834 void c_plmtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text );
1835 
1836 // Prints out "text" at specified position relative to viewport (3D)
1837 void c_plmtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text );
1838 
1839 // Plots a 3-d representation of the function z[x][y].
1840 void c_plot3d( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side );
1841 
1842 // Plots a 3-d representation of the function z[x][y] with contour.
1843 void c_plot3dc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1844  PLFLT *clevel, PLINT nlevel );
1845 
1846 // Plots a 3-d representation of the function z[x][y] with contour and
1847 // y index limits.
1848 void c_plot3dcl( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1849  PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn,
1850  PLINT *indexymin, PLINT *indexymax );
1851 
1852 //
1853 // definitions for the opt argument in plot3dc() and plsurf3d()
1854 //
1855 // DRAW_LINEX *must* be 1 and DRAW_LINEY *must* be 2, because of legacy code!
1856 //
1857 const DRAW_LINEX = 1 << 0; // draw lines parallel to the X axis
1858 const DRAW_LINEY = 1 << 1; // draw lines parallel to the Y axis
1859 const DRAW_LINEXY = DRAW_LINEX | DRAW_LINEY; // draw lines parallel to both the X and Y axis
1860 const MAG_COLOR = 1 << 2; // draw the mesh with a color dependent of the magnitude
1861 const BASE_CONT = 1 << 3; // draw contour plot at bottom xy plane
1862 const TOP_CONT = 1 << 4; // draw contour plot at top xy plane
1863 const SURF_CONT = 1 << 5; // draw contour plot at surface
1864 const DRAW_SIDES = 1 << 6; // draw sides
1865 const FACETED = 1 << 7; // draw outline for each square that makes up the surface
1866 const MESH = 1 << 8; // draw mesh
1867 
1868 //
1869 // valid options for plot3dc():
1870 //
1871 // DRAW_SIDES, BASE_CONT, TOP_CONT (not yet),
1872 // MAG_COLOR, DRAW_LINEX, DRAW_LINEY, DRAW_LINEXY.
1873 //
1874 // valid options for plsurf3d():
1875 //
1876 // MAG_COLOR, BASE_CONT, SURF_CONT, FACETED, DRAW_SIDES.
1877 //
1878 
1879 // Set fill pattern directly.
1880 void c_plpat( PLINT nlin, PLINT *inc, PLINT *del );
1881 
1882 // Plots array y against x for n points using ASCII code "code".
1883 void c_plpoin( PLINT n, PLFLT *x, PLFLT *y, PLINT code );
1884 
1885 // Draws a series of points in 3 space.
1886 void c_plpoin3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code );
1887 
1888 // Draws a polygon in 3 space.
1889 void c_plpoly3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc );
1890 
1891 // Plots array y against x for n points using (UTF-8) text string
1892 void c_plstring( PLINT n, PLFLT *x, PLFLT *y, const char *text );
1893 
1894 // Draws a series of points (described by [UTF8] text string) in 3 space.
1895 void c_plstring3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char * text );
1896 
1897 // Set the floating point precision (in number of places) in numeric labels.
1898 void c_plprec( PLINT setp, PLINT prec );
1899 
1900 // Set fill pattern, using one of the predefined patterns.
1901 void c_plpsty( PLINT patt );
1902 
1903 // Prints out "text" at world cooordinate (x,y).
1904 void c_plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text );
1905 
1906 // Prints out "text" at world cooordinate (x,y,z).
1907 void c_plptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text );
1908 
1909 // Random number generator based on Mersenne Twister.
1910 // Obtain real random number in range [0,1].
1911 PLFLT c_plrandd();
1912 
1913 // Replays contents of plot buffer to current device/file.
1914 void c_plreplot();
1915 
1916 // Set line color by red, green, blue from 0. to 1.
1917 
1918 void c_plrgb( PLFLT r, PLFLT g, PLFLT b );
1919 
1920 // Set line color by 8 bit RGB values.
1921 
1922 void c_plrgb1( PLINT r, PLINT g, PLINT b );
1923 
1924 // Functions for converting between HLS and RGB color space
1925 
1926 void c_plrgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
1927 
1928 // Set character height.
1929 
1930 void c_plschr( PLFLT def, PLFLT scale );
1931 
1932 // Set color map 0 colors by 8 bit RGB values
1933 void c_plscmap0( PLINT *r, PLINT *g, PLINT *b, PLINT ncol0 );
1934 
1935 // Set color map 0 colors by 8 bit RGB values and alpha values
1936 void c_plscmap0a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0 );
1937 
1938 // Set number of colors in cmap 0
1939 void c_plscmap0n( PLINT ncol0 );
1940 
1941 // Set color map 1 colors by 8 bit RGB values
1942 void c_plscmap1( PLINT *r, PLINT *g, PLINT *b, PLINT ncol1 );
1943 
1944 // Set color map 1 colors by 8 bit RGB and alpha values
1945 void c_plscmap1a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1 );
1946 
1947 // Set color map 1 colors using a piece-wise linear relationship between
1948 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
1949 void c_plscmap1l( PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path );
1950 
1951 // Set color map 1 colors using a piece-wise linear relationship between
1952 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
1953 // Will also linear interpolate alpha values.
1954 void c_plscmap1la( PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLBOOL *alt_hue_path );
1955 
1956 // Set number of colors in cmap 1
1957 void c_plscmap1n( PLINT ncol1 );
1958 
1959 // Set a given color from color map 0 by 8 bit RGB value
1960 void c_plscol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
1961 
1962 // Set a given color from color map 0 by 8 bit RGB value
1963 void c_plscol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
1964 
1965 // Set the background color by 8 bit RGB value
1966 void c_plscolbg( PLINT r, PLINT g, PLINT b );
1967 
1968 // Set the background color by 8 bit RGB value and alpha value
1969 void c_plscolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
1970 
1971 // Used to globally turn color output on/off
1972 void c_plscolor( PLINT color );
1973 
1974 // Set the compression level
1975 
1976 void c_plscompression( PLINT compression );
1977 
1978 // Set the device (keyword) name
1979 void c_plsdev( const char *devname );
1980 
1981 // Set window into device space using margin, aspect ratio, and
1982 // justification
1983 
1984 void c_plsdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
1985 
1986 // Set up transformation from metafile coordinates.
1987 
1988 void c_plsdimap( PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm );
1989 
1990 // Set plot orientation, specifying rotation in units of pi/2.
1991 
1992 void c_plsdiori( PLFLT rot );
1993 
1994 // Set window into plot space
1995 
1997 
1998 // Set window into plot space incrementally (zoom)
2000 
2001 // Set seed for internal random number generator
2002 void c_plseed( uint s );
2003 
2004 // Set the escape character for text strings.
2005 void c_plsesc( char esc );
2006 
2007 // Set family file parameters
2008 
2009 void c_plsfam( PLINT fam, PLINT num, PLINT bmax );
2010 
2011 // Set FCI (font characterization integer)
2012 
2013 void c_plsfci( PLUNICODE fci );
2014 
2015 // Set the output file name.
2016 void c_plsfnam( const char *fnam );
2017 
2018 // Set the current font family, style and weight
2019 
2020 void c_plsfont( PLINT family, PLINT style, PLINT weight );
2021 
2022 // Shade region.
2023 void c_plshade( PLFLT **a, PLINT nx, PLINT ny, PLINT function( PLFLT, PLFLT ) defined, PLFLT left,
2024  PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap,
2025  PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color,
2026  PLFLT max_width, void function( PLINT, PLFLT *, PLFLT* ) fill, PLBOOL rectangular,
2027  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
2028 
2029 void c_plshades( PLFLT **a, PLINT nx, PLINT ny, PLINT function( PLFLT, PLFLT ) defined, PLFLT xmin,
2030  PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT *clevel, PLINT nlevel, PLFLT fill_width,
2031  PLINT cont_color, PLFLT cont_width, void function( PLINT, PLFLT *, PLFLT* ) fill,
2032  PLBOOL rectangular, void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr,
2033  PLPointer pltr_data );
2034 
2035 void plfshade( PLFLT function( PLINT, PLINT, PLPointer ) f2eval, PLPointer f2eval_data, PLFLT function( PLINT, PLINT, PLPointer ) c2eval, PLPointer c2eval_data, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void function( PLINT, PLFLT *, PLFLT * ) fill, PLBOOL rectangular, void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
2036 
2037 // Set up lengths of major tick marks.
2038 
2039 void c_plsmaj( PLFLT def, PLFLT scale );
2040 
2041 // Set the memory area to be plotted (with the 'mem' driver)
2042 
2043 void c_plsmem( PLINT maxx, PLINT maxy, void *plotmem );
2044 
2045 // Set up lengths of minor tick marks.
2046 
2047 void c_plsmin( PLFLT def, PLFLT scale );
2048 
2049 // Set orientation. Must be done before calling plinit.
2050 
2051 void c_plsori( PLINT ori );
2052 
2053 // Set output device parameters. Usually ignored by the driver.
2054 void c_plspage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff );
2055 
2056 // Set the colors for color table 0 from a cmap0 file
2057 void c_plspal0( const char* filename );
2058 
2059 // Set the colors for color table 1 from a cmap1 file
2060 void c_plspal1( const char *filename, PLBOOL interpolate );
2061 
2062 // Set the pause (on end-of-page) status
2063 void c_plspause( PLBOOL pause );
2064 
2065 // Set stream number.
2066 
2067 void c_plsstrm( PLINT strm );
2068 
2069 // Set the number of subwindows in x and y
2070 
2071 void c_plssub( PLINT nx, PLINT ny );
2072 
2073 // Set symbol height.
2074 
2075 void c_plssym( PLFLT def, PLFLT scale );
2076 
2077 // Initialize PLplot, passing in the windows/page settings.
2078 void c_plstar( PLINT nx, PLINT ny );
2079 
2080 // Initialize PLplot, passing the device name and windows/page settings.
2081 void c_plstart( const char *devname, PLINT nx, PLINT ny );
2082 
2083 // Set the coordinate transform
2084 void c_plstransform( ct_func coordinate_transform = null, PLPointer coordinate_transform_data = null );
2085 
2086 // Add a point to a stripchart.
2087 void c_plstripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
2088 
2089 // Create 1d stripchart
2090 void c_plstripc( PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, PLINT *colline, PLINT *styline, const char **legline, const char *labx, const char *laby, const char *labtop );
2091 
2092 // Deletes and releases memory used by a stripchart.
2093 void c_plstripd( PLINT id );
2094 
2095 // plots a 2d image (or a matrix too large for plshade() )
2096 void c_plimagefr( PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2097  PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax,
2098  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ), PLPointer pltr_data );
2099 
2100 // plots a 2d image (or a matrix too large for plshade() ) - colors
2101 // automatically scaled
2102 void c_plimage( PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2103  PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
2104 
2105 // Set up a new line style
2106 void c_plstyl( PLINT nms, PLINT *mark, PLINT *space );
2107 
2108 // Plots the 3d surface representation of the function z[x][y].
2109 void c_plsurf3d( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
2110  PLFLT *clevel, PLINT nlevel );
2111 
2112 // Plots the 3d surface representation of the function z[x][y] with y
2113 // index limits.
2114 void c_plsurf3dl( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel,
2115  PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax );
2116 
2117 // Sets the edges of the viewport to the specified absolute coordinates
2118 void c_plsvpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2119 
2120 // Set x axis labeling parameters
2121 void c_plsxax( PLINT digmax, PLINT digits );
2122 
2123 // Set inferior X window
2124 void plsxwin( PLINT window_id );
2125 
2126 // Set y axis labeling parameters
2127 void c_plsyax( PLINT digmax, PLINT digits );
2128 
2129 // Plots array y against x for n points using Hershey symbol "code"
2130 void c_plsym( PLINT n, PLFLT *x, PLFLT *y, PLINT code );
2131 
2132 // Set z axis labeling parameters
2133 
2134 void c_plszax( PLINT digmax, PLINT digits );
2135 
2136 // Switches to text screen.
2137 
2138 void c_pltext();
2139 
2140 // Set the format for date / time labels
2141 void c_pltimefmt( const char *fmt );
2142 
2143 // Sets the edges of the viewport with the given aspect ratio, leaving
2144 // room for labels.
2145 
2146 void c_plvasp( PLFLT aspect );
2147 
2148 // Creates the largest viewport of the specified aspect ratio that fits
2149 // within the specified normalized subpage coordinates.
2150 
2151 void c_plvpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
2152 
2153 // Creates a viewport with the specified normalized subpage coordinates.
2154 
2155 void c_plvpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2156 
2157 // Defines a "standard" viewport with seven character heights for
2158 // the left margin and four character heights everywhere else.
2159 
2160 void c_plvsta();
2161 
2162 // Set up a window for three-dimensional plotting.
2163 
2164 void c_plw3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0, PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0, PLFLT zmax0, PLFLT alt, PLFLT az );
2165 
2166 // Set pen width.
2167 
2168 void c_plwidth( PLFLT width );
2169 
2170 // Set up world coordinates of the viewport boundaries (2d plots).
2171 
2172 void c_plwind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2173 
2174 // set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
2175 
2176 void c_plxormod( PLBOOL mode, PLBOOL *status );
2177 
2178 //--------------------------------------------------------------------------* * Functions for use from C or C++ only
2179 //--------------------------------------------------------------------------
2180 
2181 // Returns a list of file-oriented device names and their menu strings
2182 
2183 void plgFileDevs( char ***p_menustr, char ***p_devname, int *p_ndev );
2184 
2185 // Returns a list of all device names and their menu strings
2186 
2187 void plgDevs( char ***p_menustr, char ***p_devname, int *p_ndev );
2188 
2189 // Set the function pointer for the keyboard event handler
2190 
2191 void plsKeyEH( void function( PLGraphicsIn *, void *, int * ) KeyEH, void *KeyEH_data );
2192 
2193 // Set the function pointer for the (mouse) button event handler
2194 
2195 void plsButtonEH( void function( PLGraphicsIn *, void *, int * ) ButtonEH, void *ButtonEH_data );
2196 
2197 // Sets an optional user bop handler
2198 
2199 void plsbopH( void function( void *, int * ) handler, void *handler_data );
2200 
2201 // Sets an optional user eop handler
2202 
2203 void plseopH( void function( void *, int * ) handler, void *handler_data );
2204 
2205 // Set the variables to be used for storing error info
2206 
2207 void plsError( PLINT *errcode, const char *errmsg );
2208 
2209 // Sets an optional user exit handler.
2210 
2211 void plsexit( int function( const char * ) handler );
2212 
2213 // Sets an optional user abort handler.
2214 
2215 void plsabort( void function( const char * ) handler );
2216 
2217 // Transformation routines
2218 
2219 // Identity transformation.
2220 void pltr0( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2221 
2222 // Does linear interpolation from singly dimensioned coord arrays.
2223 void pltr1( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2224 
2225 // Does linear interpolation from doubly dimensioned coord arrays
2226 // (column dominant, as per normal C 2d arrays).
2227 void pltr2( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2228 
2229 // Just like pltr2() but uses pointer arithmetic to get coordinates from
2230 // 2d grid tables.
2231 void pltr2p( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2232 
2233 // Identity transformation for plots from Fortran.
2234 void pltr0f( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, void* pltr_data );
2235 
2236 // Does linear interpolation from doubly dimensioned coord arrays
2237 // (row dominant, i.e. Fortran ordering).
2238 void pltr2f( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, void* pltr_data );
2239 
2240 // Function evaluators
2241 
2242 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
2243 // and is column dominant (normal C ordering).
2244 
2245 PLFLT plf2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2246 
2247 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2248 // and is column dominant (normal C ordering).
2249 
2250 PLFLT plf2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2251 
2252 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2253 // and is row dominant (Fortran ordering).
2254 
2255 PLFLT plf2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2256 
2257 // Command line parsing utilities
2258 // Clear internal option table info structure.
2259 void plClearOpts();
2260 
2261 // Reset internal option table info structure.
2262 void plResetOpts();
2263 
2264 // Merge user option table into internal info structure.
2265 
2266 int plMergeOpts( PLOptionTable *options, const char *name, const char **notes );
2267 
2268 // Set the strings used in usage and syntax messages.
2269 
2270 void plSetUsage( const char *program_string, const char *usage_string );
2271 
2272 // Process input strings, treating them as an option and argument pair.
2273 // The first is for the external API, the second the work routine declared
2274 // here for backward compatibilty.
2275 int c_plsetopt( const char *opt, const char *optarg );
2276 
2277 int plSetOpt( const char *opt, const char *optarg );
2278 
2279 // Process options list using current options info.
2280 int c_plparseopts( int *p_argc, const char **argv, PLINT mode );
2281 
2282 // Print usage & syntax message.
2283 
2284 void plOptUsage();
2285 
2286 // Miscellaneous
2287 
2288 // Get the escape character for text strings.
2289 
2290 void plgesc( char *p_esc );
2291 
2292 // Front-end to driver escape function.
2293 
2294 void pl_cmd( PLINT op, void *ptr );
2295 
2296 // Return full pathname for given file if executable
2297 
2298 int plFindName( char *p );
2299 
2300 // Looks for the specified executable file according to usual search path.
2301 
2302 char * plFindCommand( const char *fn );
2303 
2304 // Gets search name for file by concatenating the dir, subdir, and file
2305 // name, allocating memory as needed.
2306 
2307 void plGetName( const char *dir, const char *subdir, const char *filename, char **filespec );
2308 
2309 // Prompts human to input an integer in response to given message.
2310 
2311 PLINT plGetInt( const char *s );
2312 
2313 // Prompts human to input a float in response to given message.
2314 
2315 PLFLT plGetFlt( const char *s );
2316 
2317 // Nice way to allocate space for a vectored 2d grid
2318 
2319 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
2320 
2321 void plAlloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
2322 
2323 // Frees a block of memory allocated with plAlloc2dGrid().
2324 
2325 void plFree2dGrid( PLFLT **f, PLINT nx, PLINT ny );
2326 
2327 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
2328 void plMinMax2dGrid( PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
2329 
2330 // Wait for graphics input event and translate to world coordinates
2331 
2332 int plGetCursor( PLGraphicsIn *gin );
2333 
2334 // Translates relative device coordinates to world coordinates.
2335 
2336 int plTranslateCursor( PLGraphicsIn *gin );
2337 
PLFLT wxmi
Definition: plplot.d:1123
void c_plaxes(PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plbox.c:134
void c_plgfam(PLINT *p_fam, PLINT *p_num, PLINT *p_bmax)
Definition: plcore.c:3831
#define PLESC_REDRAW
Definition: plplot.h:216
subroutine plbox(xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:148
alias _N11 PLBufferingCB
Definition: plplot.d:1253
void c_plconfigtime(PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec)
Definition: pltime.c:36
PLINT nz
Definition: plplot.d:1195
alias c_plgdidev plgdidev
Definition: plplot.d:1350
alias c_plgpage plgpage
Definition: plplot.d:1358
void plsym(PLFLT[] x, PLFLT[] y, PLINT code)
Definition: plplot.d:839
PLFLT * yg
Definition: plplot.d:1191
static PLINT text
Definition: gcw.c:97
void c_pl_setcontlabelformat(PLINT lexp, PLINT sigdig)
Definition: plcont.c:262
#define PL_OPT_FUNC
Definition: plplot.h:282
static const char * name
Definition: tkMain.c:131
void c_plptex3(PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text)
Definition: plsym.c:1950
static char ** argv
Definition: qt.cpp:40
void c_plscmap1l(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path)
void plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
void c_plgcolbga(PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:267
alias PLINT PLBOOL
Definition: plplot.d:963
#define PL_PARSE_NOPROGRAM
Definition: plplot.h:298
#define PLESC_XORMOD
Definition: plplot.h:226
void * var
Definition: plplot.d:1085
void c_plgchr(PLFLT *p_def, PLFLT *p_ht)
Definition: plcore.c:3924
PLFLT ** xg
Definition: plplot.d:1207
PLFLT * zg
Definition: plplot.d:1192
#define PLESC_DEVINIT
Definition: plplot.h:236
alias c_plgvpd plgvpd
Definition: plplot.d:1365
void c_plsfci(PLUNICODE fci)
Definition: plcore.c:3762
void c_plpsty(PLINT patt)
Definition: plsdef.c:321
void plOptUsage()
Definition: plargs.c:1255
void c_plssym(PLFLT def, PLFLT scale)
Definition: plsdef.c:248
void c_plmkstrm(PLINT *p_strm)
Definition: plcore.c:2552
void c_plseed(uint s)
#define PLESC_DOUBLEBUFFERING_ENABLE
Definition: plplot.h:481
alias c_plseed plseed
Definition: plplot.d:1428
int c_plparseopts(int *p_argc, const char **argv, PLINT mode)
Definition: plargs.c:860
void pldid2pc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1573
#define PLESC_DOUBLEBUFFERING_QUERY
Definition: plplot.h:483
#define TOP_CONT
Definition: plplot.h:1389
void plshade(PLFLT[][] a, def_func defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, PLBOOL rectangular, pltr_func pltr=null, PLPointer pltr_data=null)
Definition: plplot.d:632
void c_plsmin(PLFLT def, PLFLT scale)
Definition: plsdef.c:218
void c_plstripd(PLINT id)
Definition: plstripc.c:329
void c_plscol0a(PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:320
int type
Definition: plplot.d:1098
alias c_plgdiplt plgdiplt
Definition: plplot.d:1352
void c_plgver(char *p_ver)
Definition: plcore.c:3806
alias c_plwidth plwidth
Definition: plplot.d:1473
PLINT nx
Definition: plplot.d:1172
string syntax
Definition: plplot.d:1087
int plTranslateCursor(PLGraphicsIn *gin)
Definition: plpage.c:255
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT nx
void c_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, PLINT *colline, PLINT *styline, const char **legline, const char *labx, const char *laby, const char *labtop)
static PLFLT ** xg
int plMergeOpts(PLOptionTable *options, const char *name, const char **notes)
Definition: plargs.c:778
void c_plend()
Definition: plcore.c:2371
PLINT result
Definition: plplot.d:1251
#define PL_PARSE_QUIET
Definition: plplot.h:293
#define PL_PARSE_NODASH
Definition: plplot.h:299
void c_plgdidev(PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy)
Definition: plcore.c:1889
void c_plsstrm(PLINT strm)
Definition: plcore.c:2502
alias c_plclear plclear
Definition: plplot.d:1323
subroutine plmtex3(side, disp, pos, xjust, text)
Definition: sfstubs.f90:722
void c_plcol0(PLINT icol0)
Definition: plctrl.c:143
PLFLT wyma
Definition: plplot.d:1126
void c_plcont(PLFLT **f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
#define PL_OPT_DISABLED
Definition: plplot.h:278
void c_plscmap1la(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLBOOL *alt_hue_path)
PLFLT dymi
Definition: plplot.d:1121
int min(int a, int b)
void c_plspause(PLBOOL pause)
Definition: plcore.c:3688
void c_plot3dc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
#define SURF_CONT
Definition: plplot.h:1390
#define PLESC_FILL
Definition: plplot.h:219
subroutine plsfnam(fnam)
Definition: sfstubs.f90:92
alias c_pltext pltext
Definition: plplot.d:1465
void c_plenv(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:91
#define pllegend
Definition: plplot.h:653
alias c_plreplot plreplot
Definition: plplot.d:1403
alias c_plsxax plsxax
Definition: plplot.d:1461
alias plgvpd plP_gvpd
Definition: plplot.d:1489
#define PLESC_DOUBLEBUFFERING
Definition: plplot.h:225
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: tclAPI.c:3228
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT bb_color
void c_plline3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
#define MAG_COLOR
Definition: plplot.h:1387
PLFLT dY
Definition: plplot.d:1107
void PLFLT PLINT PLINT position
void c_plhlsrgb(PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b)
Definition: plctrl.c:1245
static PLcGrid2 * cgrid
PLUINT PLUNICODE
Definition: plplot.h:195
void c_plscompression(PLINT compression)
Definition: plcore.c:4104
subroutine plstring3(x, y, z, string)
Definition: sfstubs.f90:327
void c_plot3dcl(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax)
void plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, int npts, PLFLT *xg, int nptsx, PLFLT *yg, int nptsy, PLFLT **zg, int type, PLFLT data)
void plshades(PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLBOOL rectangular, ref PLcGrid2 cgrid2)
Definition: plplot.d:676
#define plot3dcl
Definition: plplot.h:668
alias plMinMax2dGrid MinMax2dGrid
Definition: plplot.d:1488
alias c_plarc plarc
Definition: plplot.d:1322
void c_plstring(PLINT n, PLFLT *x, PLFLT *y, const char *text)
void pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
Definition: plcont.c:1304
void plseopH(void function(void *, int *) handler, void *handler_data)
void plpoin(PLFLT[] x, PLFLT[] y, PLINT code)
Definition: plplot.d:474
alias c_plwind plwind
Definition: plplot.d:1474
static int argc
Definition: qt.cpp:39
void c_plschr(PLFLT def, PLFLT scale)
Definition: plsdef.c:203
alias c_plbop plbop
Definition: plplot.d:1316
void plstripc(PLINT *id, string xspec, string yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, PLINT[] colline, PLINT[] styline, string[] legline, string labx, string laby, string labtop)
Definition: plplot.d:711
#define plsurf3dl
Definition: plplot.h:740
void c_plszax(PLINT digmax, PLINT digits)
Definition: plcore.c:3915
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
void c_plot3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
int plFindName(char *p)
Definition: plctrl.c:2414
alias c_plsdiori plsdiori
Definition: plplot.d:1425
PLINT cmd
Definition: plplot.d:1250
void plimage(PLFLT **data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
void plmesh(PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt)
Definition: plplot.d:391
char * plFindCommand(const char *fn)
Definition: plctrl.c:2128
subroutine plmtex(side, disp, pos, xjust, text)
Definition: sfstubs.f90:705
void c_plgcompression(PLINT *compression)
Definition: plcore.c:4119
void plline(PLFLT[] x, PLFLT[] y)
Definition: plplot.d:367
alias c_plscmap1n plscmap1n
Definition: plplot.d:1415
void plFree2dGrid(PLFLT **f, PLINT nx, PLINT ny)
void c_plsmaj(PLFLT def, PLFLT scale)
Definition: plsdef.c:233
void c_plmeshc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
alias pleop plclr
Definition: plplot.d:1482
void c_plwidth(PLFLT width)
Definition: plcore.c:3627
alias c_plcpstrm plcpstrm
Definition: plplot.d:1328
void c_plscmap1n(PLINT ncol1)
Definition: plctrl.c:1051
void c_plgradient(PLINT n, PLFLT *x, PLFLT *y, PLFLT angle)
void c_plend1()
Definition: plcore.c:2429
#define PL_MAXKEY
Definition: plplot.h:351
alias c_plgfci plgfci
Definition: plplot.d:1354
subroutine plstring(x, y, string)
Definition: sfstubs.f90:309
void c_plspal0(const char *filename)
Definition: plctrl.c:1542
void plscmap0a(PLINT[] r, PLINT[] g, PLINT[] b, PLFLT[] a)
Definition: plplot.d:552
subroutine plgdev(dnam)
Definition: sfstubs.f90:80
alias c_plhlsrgb plhlsrgb
Definition: plplot.d:1372
void c_plarc(PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2, PLFLT rotate, PLBOOL fill)
Definition: plarc.c:141
alias c_pl_setcontlabelformat pl_setcontlabelformat
Definition: plplot.d:1311
#define PL_FCI_HEXPOWER_MASK
Definition: plplot.h:306
alias c_plfontld plfontld
Definition: plplot.d:1342
#define PLESC_TEXT
Definition: plplot.h:217
#define PL_PARSE_NODELETE
Definition: plplot.h:294
void c_plstransform(ct_func coordinate_transform=null, PLPointer coordinate_transform_data=null)
alias c_plsyax plsyax
Definition: plplot.d:1462
#define PL_FCI_IMPOSSIBLE
Definition: plplot.h:304
alias _N1 PLOptionTable
Definition: plplot.d:1090
void c_plscmap0a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0)
void plSetUsage(const char *program_string, const char *usage_string)
Definition: plargs.c:1238
PLFLT dxmi
Definition: plplot.d:1119
void plmap(mapform_func mapform, string type, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plplot.d:384
alias c_plgxax plgxax
Definition: plplot.d:1367
alias c_plfamadv plfamadv
Definition: plplot.d:1337
void c_plbop()
Definition: plpage.c:117
void c_plscol0(PLINT icol0, PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:284
void plsbopH(void function(void *, int *) handler, void *handler_data)
alias c_plstar plstar
Definition: plplot.d:1448
void PLFLT PLINT PLINT PLFLT x
void plline3(PLFLT[] x, PLFLT[] y, PLFLT[] z)
Definition: plplot.d:375
alias c_plstripa plstripa
Definition: plplot.d:1451
tuple xmin
Definition: Plframe.py:907
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:884
void c_plscmap0(PLINT *r, PLINT *g, PLINT *b, PLINT ncol0)
#define PL_OPT_FLOAT
Definition: plplot.h:285
void plscmap1l(PLBOOL itype, PLFLT[] intensity, PLFLT[] coord1, PLFLT[] coord2, PLFLT[] coord3, PLBOOL[] alt_hue_path=null)
Definition: plplot.d:582
alias c_plmkstrm plmkstrm
Definition: plplot.d:1387
void c_plvsta()
Definition: plvpor.c:309
void plbin(PLFLT[] x, PLFLT[] y, PLINT opt)
Definition: plplot.d:137
alias void * PLPointer
Definition: plplot.d:966
PLFLT ** f
Definition: plplot.d:1171
PLFLT * xg
Definition: plplot.d:1190
void plpat(PLINT[] inc, PLINT[] del)
Definition: plplot.d:466
void c_plfont(PLINT ifont)
Definition: plsym.c:1309
alias c_plvpor plvpor
Definition: plplot.d:1470
void plsabort(void function(const char *) handler)
void plGetName(const char *dir, const char *subdir, const char *filename, char **filespec)
Definition: plctrl.c:2435
void c_plline(PLINT n, PLFLT *x, PLFLT *y)
uint keysym
Definition: plplot.d:1100
#define GRID_DTLI
Definition: plplot.h:1109
void * PLPointer
Definition: plplot.h:201
PLFLT a
Definition: plplot.d:1227
void c_plsurf3dl(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax)
alias uint PLUNICODE
Definition: plplot.d:959
alias c_plsdidev plsdidev
Definition: plplot.d:1423
alias c_plcalc_world plcalc_world
Definition: plplot.d:1321
void c_plflush()
Definition: plcore.c:2112
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
void c_plprec(PLINT setp, PLINT prec)
Definition: plcore.c:3696
#define PLESC_DI
Definition: plplot.h:220
void c_plbox(const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plbox.c:88
void c_plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, PLINT npts, PLFLT *xg, PLINT nptsx, PLFLT *yg, PLINT nptsy, PLFLT **zg, PLINT type, PLFLT data)
void plResetOpts()
Definition: plargs.c:838
void c_plsdiori(PLFLT rot)
Definition: plcore.c:1904
tuple ymin
Definition: Plframe.py:908
void c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
alias c_plgdiori plgdiori
Definition: plplot.d:1351
void plsKeyEH(void function(PLGraphicsIn *, void *, int *) KeyEH, void *KeyEH_data)
void c_pllegend(PLFLT *p_legend_width, PLFLT *p_legend_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLINT nrow, PLINT ncolumn, PLINT nlegend, PLINT *opt_array, PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing, PLFLT text_justification, PLINT *text_colors, const char **text, PLINT *box_colors, PLINT *box_patterns, PLFLT *box_scales, PLFLT *box_line_widths, PLINT *line_colors, PLINT *line_styles, PLFLT *line_widths, PLINT *symbol_colors, PLFLT *symbol_scales, PLINT *symbol_numbers, const char **symbols)
alias _N3 PLWindow
Definition: plplot.d:1128
alias c_plrgbhls plrgbhls
Definition: plplot.d:1406
static PLFLT ** yg
void plsError(PLINT *errcode, const char *errmsg)
void plsButtonEH(void function(PLGraphicsIn *, void *, int *) ButtonEH, void *ButtonEH_data)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
alias c_plmeridians plmeridians
Definition: plplot.d:1384
void c_plmtex3(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plsym.c:1578
#define MESH
Definition: plplot.h:1393
subroutine plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)
Definition: sfstubs.f90:166
PLFLT ** yg
Definition: plplot.d:1208
void c_plrgb(PLFLT r, PLFLT g, PLFLT b)
alias c_plstripd plstripd
Definition: plplot.d:1453
#define GRID_NNIDW
Definition: plplot.h:1111
void plsexit(int function(const char *) handler)
PLDLLIMPEXP void c_plmeridians(void(*mapform)(PLINT, PLFLT *, PLFLT *), PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
void plscmap1la(PLBOOL itype, PLFLT[] intensity, PLFLT[] coord1, PLFLT[] coord2, PLFLT[] coord3, PLFLT[] a, PLBOOL[] alt_hue_path=null)
Definition: plplot.d:602
void c_plsfnam(const char *fnam)
Definition: plcore.c:3680
void plvect(PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid2 cgrid2)
Definition: plplot.d:94
int PLINT
Definition: plplot.h:175
void plMinMax2dGrid(PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin)
#define BASE_CONT
Definition: plplot.h:1388
void plscmap1(PLINT[] r, PLINT[] g, PLINT[] b)
Definition: plplot.d:562
void c_plfamadv()
Definition: plcore.c:3857
alias c_plsdiplt plsdiplt
Definition: plplot.d:1426
PLINT PLBOOL
Definition: plplot.h:198
#define PL_OPT_ENABLED
Definition: plplot.h:274
void c_plgzax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:3906
void c_plsurf3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
uint height
Definition: plplot.d:1138
void c_plgdev(char *p_dev)
Definition: plcore.c:3508
PLFLT wX
Definition: plplot.d:1108
void c_plgvpw(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:3944
void c_plsvpa(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:510
void plfcont(PLFLT function(PLINT, PLINT, PLPointer) f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
alias c_plschr plschr
Definition: plplot.d:1407
void c_pladv(PLINT page)
Definition: plpage.c:35
alias c_plsmaj plsmaj
Definition: plplot.d:1437
void pldip2dc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1619
void c_plgfnam(char *fnam)
Definition: plcore.c:3661
void c_plgxax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:3870
#define FACETED
Definition: plplot.h:1392
void c_plscolbg(PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:217
alias c_plvpas plvpas
Definition: plplot.d:1469
void c_plstar(PLINT nx, PLINT ny)
Definition: plcore.c:2168
void c_plptex(PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text)
Definition: plsym.c:707
alias c_plspage plspage
Definition: plplot.d:1441
alias c_plgfam plgfam
Definition: plplot.d:1353
void c_plfill3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
void c_plw3d(PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0, PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0, PLFLT zmax0, PLFLT alt, PLFLT az)
Definition: plwind.c:139
void c_plbin(PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt)
#define PL_NOTSET
Definition: plplot.h:388
void c_plmtex(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plsym.c:567
PLINT subwindow
Definition: plplot.d:1102
alias c_plgyax plgyax
Definition: plplot.d:1368
#define PL_PARSE_PARTIAL
Definition: plplot.h:291
alias plbop plpage
Definition: plplot.d:1483
void c_plsxax(PLINT digmax, PLINT digits)
Definition: plcore.c:3879
PLINT nx
Definition: plplot.d:1158
static void pltr(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
Definition: f77/sccont.c:211
void c_plhist(PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt)
void c_plsdiplz(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1688
PLINT nx
Definition: plplot.d:1210
alias c_plssym plssym
Definition: plplot.d:1447
void c_plbtime(PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime)
Definition: pltime.c:28
alias c_plsvpa plsvpa
Definition: plplot.d:1460
alias _N7 c_PLcGrid
Definition: plplot.d:1197
alias c_plgstrm plgstrm
Definition: plplot.d:1363
alias c_plgfont plgfont
Definition: plplot.d:1356
#define PL_OPT_NODELETE
Definition: plplot.h:276
void c_plstripa(PLINT id, PLINT pen, PLFLT x, PLFLT y)
Definition: plstripc.c:223
void c_plsori(PLINT ori)
Definition: plcore.c:3615
void c_plcpstrm(PLINT iplsr, PLBOOL flags)
Definition: plcore.c:2642
alias c_plscompression plscompression
Definition: plplot.d:1421
#define GRID_NNI
Definition: plplot.h:1110
#define PLESC_GRAPH
Definition: plplot.h:218
void c_plcol1(PLFLT col1)
Definition: plctrl.c:177
subroutine plgver(ver)
Definition: sfstubs.f90:117
alias c_pljoin pljoin
Definition: plplot.d:1376
alias c_plspause plspause
Definition: plplot.d:1444
#define PLESC_SET_COMPRESSION
Definition: plplot.h:227
void c_plmesh(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt)
void plfshade(PLFLT function(PLINT, PLINT, PLPointer) f2eval, PLPointer f2eval_data, PLFLT function(PLINT, PLINT, PLPointer) c2eval, PLPointer c2eval_data, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void function(PLINT, PLFLT *, PLFLT *) fill, PLBOOL rectangular, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
void PLFLT PLINT PLINT PLFLT PLFLT y
void plerrx(PLFLT[] xmin, PLFLT[] xmax, PLFLT[] y)
Definition: plplot.d:225
#define PL_MAXWINDOWS
Definition: plplot.h:368
#define PLESC_SET_RGB
Definition: plplot.h:211
ubyte b
Definition: plplot.d:1226
#define PLESC_RESIZE
Definition: plplot.h:215
void c_plsyax(PLINT digmax, PLINT digits)
Definition: plcore.c:3897
subroutine plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:130
uint y
Definition: plplot.d:1136
PLFLT wymi
Definition: plplot.d:1125
void c_plgspa(PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax)
Definition: plpage.c:218
PLFLT p
Definition: plplot.d:1239
alias c_plslabelfunc plslabelfunc
Definition: plplot.d:1320
alias c_plenv plenv
Definition: plplot.d:1332
alias c_plconfigtime plconfigtime
Definition: plplot.d:1326
void c_plhls(PLFLT h, PLFLT l, PLFLT s)
void c_plrgbhls(PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s)
Definition: plctrl.c:1278
#define PL_FCI_STYLE
Definition: plplot.h:310
void c_plcalc_world(PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window)
Definition: plpage.c:285
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
void plClearOpts()
Definition: plargs.c:825
void c_plrgb1(PLINT r, PLINT g, PLINT b)
void c_plstyl(PLINT nms, PLINT *mark, PLINT *space)
void c_plssub(PLINT nx, PLINT ny)
Definition: plcore.c:3470
void c_plsdev(const char *devname)
Definition: plcore.c:3490
void c_plvpas(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect)
Definition: plvpor.c:388
alias c_plsmem plsmem
Definition: plplot.d:1438
#define PLESC_EH
Definition: plplot.h:222
subroutine plspal0(filename)
Definition: sfstubs.f90:676
alias c_plhls plhls
Definition: plplot.d:1371
void c_plvpor(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:344
alias c_plglevel plglevel
Definition: plplot.d:1357
#define PL_Y_AXIS
Definition: plplot.h:267
#define PLESC_CLEAR
Definition: plplot.h:228
void c_plclear()
Definition: plpage.c:71
alias c_plscolor plscolor
Definition: plplot.d:1420
alias c_plinit plinit
Definition: plplot.d:1375
alias c_plcol1 plcol1
Definition: plplot.d:1325
#define PLESC_ALLOC_NCOL
Definition: plplot.h:212
alias c_plgchr plgchr
Definition: plplot.d:1343
PLFLT wY
Definition: plplot.d:1109
alias c_plsdiplz plsdiplz
Definition: plplot.d:1427
void c_plsdidev(PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy)
Definition: plcore.c:1774
void plgFileDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:1123
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:951
void c_plgcolbg(PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:251
void c_pl_setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
Definition: plcont.c:253
PLFLT[][] yg
Definition: plplot.d:32
int alt_hue_path
Definition: plplot.d:1241
#define PL_OPT_INVISIBLE
Definition: plplot.h:277
#define PL_OPT_BOOL
Definition: plplot.h:283
#define DRAW_SIDES
Definition: plplot.h:1391
void c_pljoin(PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:64
alias c_plpsty plpsty
Definition: plplot.d:1399
#define PL_Z_AXIS
Definition: plplot.h:268
void c_plgvpd(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:3933
alias _N8 c_PLcGrid2
Definition: plplot.d:1213
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:472
void c_plsfam(PLINT fam, PLINT num, PLINT bmax)
Definition: plcore.c:3841
PLFLT[] xg
Definition: plplot.d:25
#define PLSWIN_WORLD
Definition: plplot.h:263
int plparseopts(char[][] args, PLINT mode)
Definition: plplot.d:56
subroutine plsetopt(opt, optarg)
Definition: sfstubs.f90:39
void plsxwin(PLINT window_id)
Definition: plcore.c:3814
alias c_plscolbga plscolbga
Definition: plplot.d:1419
void c_plglevel(PLINT *p_level)
Definition: plcore.c:3557
#define DRAW_LINEXY
Definition: plplot.h:1386
alias _N10 PLControlPt
Definition: plplot.d:1243
PLFLT s
Definition: plplot.d:1238
subroutine plptex(x, y, dx, dy, xjust, text)
Definition: sfstubs.f90:739
alias c_plscolbg plscolbg
Definition: plplot.d:1418
tuple xmax
Definition: Plframe.py:909
void c_plsdimap(PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm)
Definition: plcore.c:2042
void c_plimage(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
PLFLT h
Definition: plplot.d:1236
#define ZEROW2D
Definition: plplot.h:256
void c_plctime(PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime)
Definition: pltime.c:54
PLFLT dyma
Definition: plplot.d:1122
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT cont_color
alias plgvpw plP_gvpw
Definition: plplot.d:1490
subroutine plgfnam(fnam)
Definition: sfstubs.f90:105
void c_plshade(PLFLT **a, PLINT nx, PLINT ny, PLINT function(PLFLT, PLFLT) defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void function(PLINT, PLFLT *, PLFLT *) fill, PLBOOL rectangular, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
int mode
Definition: plplot.d:1086
void c_plstart(const char *devname, PLINT nx, PLINT ny)
Definition: plcore.c:2187
PLFLT[][] zg
Definition: plplot.d:33
void c_plgfont(PLINT *p_family, PLINT *p_style, PLINT *p_weight)
Definition: plsym.c:2106
#define PL_X_AXIS
Definition: plplot.h:266
alias c_plxormod plxormod
Definition: plplot.d:1476
void c_plsfont(PLINT family, PLINT style, PLINT weight)
Definition: plsym.c:2062
void plsvect(PLFLT[] arrowx, PLFLT[] arrowy, PLBOOL fill)
Definition: plplot.d:121
void c_plsdiplt(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1664
uint state
Definition: plplot.d:1099
void c_plfontld(PLINT fnt)
Definition: plcore.c:3334
subroutine pllab(xlab, ylab, title)
Definition: sfstubs.f90:658
void plmeshc(PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel)
Definition: plplot.d:403
void c_plpoin(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
PLFLT plGetFlt(const char *s)
Definition: plctrl.c:2918
PLINT ny
Definition: plplot.d:1211
#define PLSWIN_DEVICE
Definition: plplot.h:262
alias c_plflush plflush
Definition: plplot.d:1340
#define PL_OPT_INT
Definition: plplot.h:284
alias c_plsori plsori
Definition: plplot.d:1440
void plcont(PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel, ref PLcGrid2 cgrid2)
Definition: plplot.d:191
static PLOptionTable options[]
Definition: tclMain.c:120
void c_pllightsource(PLFLT x, PLFLT y, PLFLT z)
Definition: plot3d.c:101
alias c_plrgb1 plrgb1
Definition: plplot.d:1405
#define PL_OPT_STRING
Definition: plplot.h:286
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:453
subroutine plsdev(dnam)
Definition: sfstubs.f90:67
void c_pltext()
Switches to text screen.
Definition: plctrl.c:2083
void c_plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:434
#define PL_OPT_ARG
Definition: plplot.h:275
alias c_plsmin plsmin
Definition: plplot.d:1439
PLFLT[][] xg
Definition: plplot.d:31
uint button
Definition: plplot.d:1101
#define DRAW_LINEX
Definition: plplot.h:1384
alias c_plscol0a plscol0a
Definition: plplot.d:1417
alias c_plbtime plbtime
Definition: plplot.d:1319
void c_plxormod(PLBOOL mode, PLBOOL *status)
Definition: plctrl.c:2001
#define PLESC_SWIN
Definition: plplot.h:224
#define PLESC_SET_LPB
Definition: plplot.h:213
void c_pltimefmt(const char *fmt)
Definition: pltime.c:64
alias c_plw3d plw3d
Definition: plplot.d:1472
void c_plsym(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
PLINT nz
Definition: plplot.d:1160
alias _N5 PLfGrid
Definition: plplot.d:1162
#define ONEW2D
Definition: plplot.h:258
void c_plsmem(PLINT maxx, PLINT maxy, void *plotmem)
Definition: plcore.c:3523
float PLFLT
Definition: plplot.h:159
#define PL_PARSE_FULL
Definition: plplot.h:292
void c_plscmap1(PLINT *r, PLINT *g, PLINT *b, PLINT ncol1)
string opt
Definition: plplot.d:1082
void plerry(PLFLT[] x, PLFLT[] ymin, PLFLT[] ymax)
Definition: plplot.d:234
alias c_plgzax plgzax
Definition: plplot.d:1369
void c_plgdiori(PLFLT *p_rot)
Definition: plcore.c:2027
#define PL_FCI_FAMILY
Definition: plplot.h:309
PLINT ny
Definition: plplot.d:1159
#define PLESC_DOUBLEBUFFERING_DISABLE
Definition: plplot.h:482
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
alias _N2 PLGraphicsIn
Definition: plplot.d:1111
alias _N4 PLDisplay
Definition: plplot.d:1140
void c_plscmap1a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1)
alias c_plfont plfont
Definition: plplot.d:1341
void PLFLT PLINT opt
alias c_plvasp plvasp
Definition: plplot.d:1467
void c_plspage(PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff)
Definition: plcore.c:3444
PLFLT c_plrandd()
Definition: plctrl.c:3054
alias c_plsfam plsfam
Definition: plplot.d:1431
#define PL_PARSE_SKIP
Definition: plplot.h:300
alias plAlloc2dGrid Alloc2dGrid
Definition: plplot.d:1486
void plstyl(PLINT[] mark, PLINT[] space)
Definition: plplot.d:803
alias c_plrandd plrandd
Definition: plplot.d:1402
void c_plslabelfunc(void function(PLINT, PLFLT, char *, PLINT, PLPointer) labelfunc, PLPointer label_data)
PLFLT wxma
Definition: plplot.d:1124
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT cont_width
#define PL_FCI_WEIGHT
Definition: plplot.h:311
PLINT nx
Definition: plplot.d:1193
void c_plspal1(const char *filename, PLBOOL interpolate)
Definition: plctrl.c:1598
alias plcol0 plcol
Definition: plplot.d:1484
uint width
Definition: plplot.d:1137
alias c_pleop pleop
Definition: plplot.d:1334
subroutine plspal1(filename, interpolate)
Definition: sfstubs.f90:690
int plSetOpt(const char *opt, const char *optarg)
Definition: plargs.c:738
void c_plgra()
Definition: plctrl.c:1986
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT bb_style
void plAlloc2dGrid(PLFLT ***f, PLINT nx, PLINT ny)
Definition: pdfutils.c:1104
PLFLT ** convert_array(PLFLT[][] a)
Definition: plplot.d:37
void c_plgyax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:3888
tuple ymax
Definition: Plframe.py:910
PLFLT l
Definition: plplot.d:1237
subroutine plstart(devname, nx, ny)
Definition: sfstubs.f90:769
alias c_plprec plprec
Definition: plplot.d:1398
void plgDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
alias c_plgcol0 plgcol0
Definition: plplot.d:1344
int c_plsetopt(const char *opt, const char *optarg)
Definition: plargs.c:744
alias c_plsfci plsfci
Definition: plplot.d:1432
void c_plerrx(PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y)
alias c_plstransform plstransform
Definition: plplot.d:1450
void c_plgpage(PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng, PLINT *p_xoff, PLINT *p_yoff)
Definition: plcore.c:3430
alias c_plend1 plend1
Definition: plplot.d:1331
alias c_plgspa plgspa
Definition: plplot.d:1362
#define PLESC_HAS_TEXT
Definition: plplot.h:230
PLFLT ** zg
Definition: plplot.d:1209
alias c_plgcolbga plgcolbga
Definition: plplot.d:1347
void c_plerry(PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax)
alias c_pllightsource pllightsource
Definition: plplot.d:1379
subroutine plptex3(x, y, z, dx, dy, dz, sx, sy, sz, xjust, text)
Definition: sfstubs.f90:754
void plsurf3d(PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel=null)
Definition: plplot.d:811
alias plfcont plcontf
Definition: plplot.d:1485
char[16] string
Definition: plplot.d:1103
alias c_plssub plssub
Definition: plplot.d:1446
int plGetCursor(PLGraphicsIn *gin)
Definition: plpage.c:240
PLFLT a
Definition: plplot.d:1240
alias c_plgradient plgrdient
Definition: plplot.d:1359
void c_plgstrm(PLINT *p_strm)
Definition: plcore.c:2533
void pltr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
Definition: f77/sccont.c:36
PLFLT dxma
Definition: plplot.d:1120
void c_plwind(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plwind.c:35
alias c_plgcolbg plgcolbg
Definition: plplot.d:1345
alias c_plsesc plsesc
Definition: plplot.d:1429
void plgradient(PLFLT[] x, PLFLT[] y, PLFLT angle)
Definition: plplot.d:276
#define PLESC_IMAGE
Definition: plplot.h:231
void plot3dc(PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel)
Definition: plplot.d:439
alias c_plgra plgra
Definition: plplot.d:1360
void plfill(PLFLT[] x, PLFLT[] y)
Definition: plplot.d:243
void plfill3(PLFLT[] x, PLFLT[] y, PLFLT[] z)
Definition: plplot.d:251
#define PL_PARSE_SHOWALL
Definition: plplot.h:296
void c_plinit()
Definition: plcore.c:2207
static char errmsg[160]
Definition: tclAPI.c:136
void c_pllab(const char *xlabel, const char *ylabel, const char *tlabel)
Definition: plsym.c:522
#define PLESC_DEV2PLCOL
Definition: plplot.h:234
#define PLESC_SETBGFG
Definition: plplot.h:235
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT bg_color
alias c_plctime plctime
Definition: plplot.d:1329
ubyte r
Definition: plplot.d:1224
#define PLESC_IMAGEOPS
Definition: plplot.h:232
#define PLESC_DASH
Definition: plplot.h:229
void plscmap1a(PLINT[] r, PLINT[] g, PLINT[] b, PLFLT[] a)
Definition: plplot.d:571
void c_plenv0(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:105
ubyte g
Definition: plplot.d:1225
#define PL_FCI_HEXDIGIT_MASK
Definition: plplot.h:305
void c_plscmap0n(PLINT ncol0)
Definition: plctrl.c:926
alias c_plgcol0a plgcol0a
Definition: plplot.d:1346
void pl_cmd(PLINT op, void *ptr)
Definition: plctrl.c:2101
alias c_plrgb plrgb
Definition: plplot.d:1404
void c_plvasp(PLFLT aspect)
Definition: plvpor.c:458
#define PL_PARSE_OVERRIDE
Definition: plplot.h:297
alias c_plscol0 plscol0
Definition: plplot.d:1416
alias c_pl_setcontlabelparam pl_setcontlabelparam
Definition: plplot.d:1312
void c_plgdiplt(PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax)
Definition: plcore.c:1754
void c_plscolbga(PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:236
dx
if { $zoomopts($this,1) == 0 } then {
Definition: Plframe.py:613
PLFLT[] yg
Definition: plplot.d:26
alias _N6 PLfGrid2
Definition: plplot.d:1175
void c_plreplot()
Definition: plcore.c:3352
void c_plscolor(PLINT color)
Definition: plctrl.c:1186
alias int PLINT
Definition: plplot.d:960
PLFLT * f
Definition: plplot.d:1157
#define DRAW_LINEY
Definition: plplot.h:1385
void c_plgcol0(PLINT icol0, PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:361
void plhist(PLFLT[] data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt)
Definition: plplot.d:307
void c_plstring3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char *text)
void c_plpat(PLINT nlin, PLINT *inc, PLINT *del)
void c_plgcol0a(PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:398
#define PLESC_GETC
Definition: plplot.h:223
alias c_plsdimap plsdimap
Definition: plplot.d:1424
#define PLESC_PL2DEVCOL
Definition: plplot.h:233
void plscmap0(PLINT[] r, PLINT[] g, PLINT[] b)
Definition: plplot.d:543
void c_plshades(PLFLT **a, PLINT nx, PLINT ny, PLINT function(PLFLT, PLFLT) defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT *clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, void function(PLINT, PLFLT *, PLFLT *) fill, PLBOOL rectangular, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
alias c_plenv0 plenv0
Definition: plplot.d:1333
alias c_plend plend
Definition: plplot.d:1330
alias c_plszax plszax
Definition: plplot.d:1464
PLDLLIMPEXP void c_plmap(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *type, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
void c_plgfci(PLUNICODE *pfci)
Definition: plcore.c:3772
void c_plsesc(char esc)
Definition: plcore.c:3726
alias _N9 PLColor
Definition: plplot.d:1230
alias c_plgvpw plgvpw
Definition: plplot.d:1366
void c_plpoly3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc)
PLINT ny
Definition: plplot.d:1173
alias c_pladv pladv
Definition: plplot.d:1313
void * client_data
Definition: plplot.d:1084
subroutine pltimefmt(fmt)
Definition: sfstubs.f90:784
#define PLESC_EXPOSE
Definition: plplot.h:214
#define ZEROW2B
Definition: plplot.h:255
#define PL_FCI_HEXPOWER_IMPOSSIBLE
Definition: plplot.h:307
void c_pllsty(PLINT lin)
Definition: plsdef.c:263
PLFLT dX
Definition: plplot.d:1106
void c_plbox3(const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx, const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby, const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz)
Definition: plbox.c:593
alias c_plgcompression plgcompression
Definition: plplot.d:1348
alias c_pllsty pllsty
Definition: plplot.d:1382
#define ONEW2B
Definition: plplot.h:257
void plpoin3(PLFLT[] x, PLFLT[] y, PLFLT[] z, PLINT code)
Definition: plplot.d:482
PLFLT[] zg
Definition: plplot.d:27
void c_pleop()
Definition: plpage.c:101
void plot3d(PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLBOOL side)
Definition: plplot.d:427
void c_plvect(PLFLT **u, PLFLT **v, PLINT nx, PLINT ny, PLFLT scale, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
PLINT ny
Definition: plplot.d:1194
void c_plsvect(PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill)
uint x
Definition: plplot.d:1135
alias c_plsstrm plsstrm
Definition: plplot.d:1445
#define GRID_NNAIDW
Definition: plplot.h:1113
#define GRID_NNLI
Definition: plplot.h:1112
alias c_plscmap0n plscmap0n
Definition: plplot.d:1410
void c_plfill(PLINT n, PLFLT *x, PLFLT *y)
char * name
Definition: plplot.d:1228
alias plFree2dGrid Free2dGrid
Definition: plplot.d:1487
void plgesc(char *p_esc)
Definition: plcore.c:3750
alias c_plsfont plsfont
Definition: plplot.d:1434
alias c_plvsta plvsta
Definition: plplot.d:1471
string desc
Definition: plplot.d:1088
#define PLESC_FLUSH
Definition: plplot.h:221
alias c_plcol0 plcol0
Definition: plplot.d:1324
#define PL_FCI_MARK
Definition: plplot.h:303
void plpoly3(PLFLT[] x, PLFLT[] y, PLFLT[] z, PLBOOL[] draw, PLBOOL ifcc)
Definition: plplot.d:508
#define GRID_CSA
Definition: plplot.h:1108
PLINT plGetInt(const char *s)
Definition: plctrl.c:2883