00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #include "plplot.h"
00030 #include "plstream.h"
00031
00032 #include <iostream>
00033
00034 #ifdef PL_USE_NAMESPACE
00035 using namespace std;
00036 #endif
00037
00038 PLFLT Contourable_Data_evaluator( PLINT i, PLINT j, PLPointer p )
00039 {
00040 const Contourable_Data& d = *(Contourable_Data *) p;
00041
00042 return d( i, j );
00043 }
00044
00045 void Coord_Xform_evaluator( PLFLT ox, PLFLT oy,
00046 PLFLT *nx, PLFLT *ny, PLPointer p )
00047 {
00048 const Coord_Xformer& xf = *(Coord_Xformer *) p;
00049
00050 xf.xform( ox, oy, *nx, *ny );
00051 }
00052
00053
00054
00055
00056 cxx_pltr2::cxx_pltr2( Coord_2d& cx, Coord_2d& cy )
00057 : xg( cx ), yg( cy )
00058 {
00059 }
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076 void cxx_pltr2::xform( PLFLT x, PLFLT y, PLFLT& tx, PLFLT& ty ) const
00077 {
00078 int nx, ny;
00079 xg.elements( nx, ny );
00080
00081 int ul, ur, vl, vr;
00082 PLFLT du, dv;
00083
00084 PLFLT xll, xlr, xrl, xrr;
00085 PLFLT yll, ylr, yrl, yrr;
00086 PLFLT xmin, xmax, ymin, ymax;
00087
00088 ul = (int) x;
00089 ur = ul + 1;
00090 du = x - ul;
00091
00092 vl = (int) y;
00093 vr = vl + 1;
00094 dv = y - vl;
00095
00096 xmin = 0;
00097 xmax = nx - 1;
00098 ymin = 0;
00099 ymax = ny - 1;
00100
00101 if ( x < xmin || x > xmax || y < ymin || y > ymax )
00102 {
00103 cerr << "cxx_pltr2::xform, Invalid coordinates\n";
00104
00105 if ( x < xmin )
00106 {
00107 if ( y < ymin )
00108 {
00109 tx = xg( 0, 0 );
00110 ty = yg( 0, 0 );
00111 }
00112 else if ( y > ymax )
00113 {
00114 tx = xg( 0, ny - 1 );
00115 ty = yg( 0, ny - 1 );
00116 }
00117 else
00118 {
00119 xll = xg( 0, vl );
00120 yll = yg( 0, vl );
00121 xlr = xg( 0, vr );
00122 ylr = yg( 0, vr );
00123
00124 tx = xll * ( 1 - dv ) + xlr * ( dv );
00125 ty = yll * ( 1 - dv ) + ylr * ( dv );
00126 }
00127 }
00128 else if ( x > xmax )
00129 {
00130 if ( y < ymin )
00131 {
00132 tx = xg( nx - 1, 0 );
00133 ty = yg( nx - 1, 0 );
00134 }
00135 else if ( y > ymax )
00136 {
00137 tx = xg( nx - 1, ny - 1 );
00138 ty = yg( nx - 1, ny - 1 );
00139 }
00140 else
00141 {
00142 xll = xg( nx - 1, vl );
00143 yll = yg( nx - 1, vl );
00144 xlr = xg( nx - 1, vr );
00145 ylr = yg( nx - 1, vr );
00146
00147 tx = xll * ( 1 - dv ) + xlr * ( dv );
00148 ty = yll * ( 1 - dv ) + ylr * ( dv );
00149 }
00150 }
00151 else
00152 {
00153 if ( y < ymin )
00154 {
00155 xll = xg( ul, 0 );
00156 xrl = xg( ur, 0 );
00157 yll = yg( ul, 0 );
00158 yrl = yg( ur, 0 );
00159
00160 tx = xll * ( 1 - du ) + xrl * ( du );
00161 ty = yll * ( 1 - du ) + yrl * ( du );
00162 }
00163 else if ( y > ymax )
00164 {
00165 xlr = xg( ul, ny - 1 );
00166 xrr = xg( ur, ny - 1 );
00167 ylr = yg( ul, ny - 1 );
00168 yrr = yg( ur, ny - 1 );
00169
00170 tx = xlr * ( 1 - du ) + xrr * ( du );
00171 ty = ylr * ( 1 - du ) + yrr * ( du );
00172 }
00173 }
00174 }
00175
00176
00177
00178
00179
00180
00181 else
00182 {
00183 xll = xg( ul, vl );
00184 yll = yg( ul, vl );
00185
00186
00187
00188 if ( ur == nx && vr < ny )
00189 {
00190 xlr = xg( ul, vr );
00191 ylr = yg( ul, vr );
00192
00193 tx = xll * ( 1 - dv ) + xlr * ( dv );
00194 ty = yll * ( 1 - dv ) + ylr * ( dv );
00195 }
00196
00197
00198
00199 else if ( ur < nx && vr == ny )
00200 {
00201 xrl = xg( ur, vl );
00202 yrl = yg( ur, vl );
00203
00204 tx = xll * ( 1 - du ) + xrl * ( du );
00205 ty = yll * ( 1 - du ) + yrl * ( du );
00206 }
00207
00208
00209
00210 else if ( ur == nx && vr == ny )
00211 {
00212 tx = xll;
00213 ty = yll;
00214 }
00215
00216
00217
00218 else
00219 {
00220 xrl = xg( ur, vl );
00221 xlr = xg( ul, vr );
00222 xrr = xg( ur, vr );
00223
00224 yrl = yg( ur, vl );
00225 ylr = yg( ul, vr );
00226 yrr = yg( ur, vr );
00227
00228 tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
00229 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
00230
00231 ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
00232 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
00233 }
00234 }
00235 }
00236
00237 PLINT plstream::active_streams = 0;
00238
00239 plstream::plstream()
00240 {
00241 ::c_plmkstrm( &stream );
00242
00243 active_streams++;
00244 }
00245
00246 plstream::plstream ( PLS::stream_id sid, PLINT strm )
00247 {
00248 switch ( sid )
00249 {
00250 case PLS::Next:
00251
00252 break;
00253
00254 case PLS::Current:
00255 ::c_plgstrm( &stream );
00256 break;
00257
00258 case PLS::Specific:
00259 stream = strm;
00260 break;
00261
00262 default:
00263
00264 break;
00265 }
00266 }
00267
00268 plstream::plstream( PLINT nx, PLINT ny, const char *driver, const char *file )
00269 {
00270 ::c_plmkstrm( &stream );
00271
00272 if ( driver )
00273 ::c_plsdev( driver );
00274 if ( file )
00275 ::c_plsfnam( file );
00276 ::c_plssub( nx, ny );
00277
00278
00279 active_streams++;
00280 }
00281
00282 plstream::plstream( PLINT nx, PLINT ny, PLINT r, PLINT g, PLINT b,
00283 const char *driver, const char *file )
00284 {
00285 ::c_plmkstrm( &stream );
00286
00287 if ( driver )
00288 ::c_plsdev( driver );
00289 if ( file )
00290 ::c_plsfnam( file );
00291 ::c_plssub( nx, ny );
00292 ::c_plscolbg( r, g, b );
00293
00294
00295 active_streams++;
00296 }
00297
00298 plstream::~plstream()
00299 {
00300 ::c_plsstrm( stream );
00301 ::c_plend1();
00302
00303 active_streams--;
00304 if ( !active_streams )
00305 ::c_plend();
00306 }
00307
00308 #define BONZAI { throw "plstream method not implemented."; }
00309
00310
00311
00312
00313
00314 void
00315 plstream::adv( PLINT page )
00316 {
00317 set_stream();
00318
00319 pladv( page );
00320 }
00321
00322 void
00323 plstream::arc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
00324 PLFLT rotate, PLBOOL fill )
00325 {
00326 set_stream();
00327
00328 plarc( x, y, a, b, angle1, angle2, rotate, fill );
00329 }
00330
00331 void
00332 plstream::vect( const PLFLT * const *u, const PLFLT * const *v, PLINT nx, PLINT ny, PLFLT scale,
00333 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00334 PLPointer pltr_data )
00335 {
00336 set_stream();
00337
00338 plvect( (const PLFLT **) u, (const PLFLT **) v, nx, ny, scale, pltr, pltr_data );
00339 }
00340
00341 void
00342 plstream::svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, bool fill )
00343 {
00344 set_stream();
00345
00346 plsvect( arrow_x, arrow_y, npts, (PLBOOL) fill );
00347 }
00348
00349
00350 void
00351 plstream::svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, PLINT fill )
00352 {
00353 set_stream();
00354
00355 plsvect( arrow_x, arrow_y, npts, (PLBOOL) fill );
00356 }
00357
00358
00359
00360
00361 void
00362 plstream::axes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
00363 const char *yopt, PLFLT ytick, PLINT nysub )
00364 {
00365 set_stream();
00366
00367 plaxes( x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub );
00368 }
00369
00370
00371
00372 void plstream::bin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center )
00373 {
00374 set_stream();
00375
00376 plbin( nbin, x, y, center );
00377 }
00378
00379
00380
00381 void plstream::bop()
00382 {
00383 set_stream();
00384
00385 plbop();
00386 }
00387
00388
00389
00390 void plstream::box( const char *xopt, PLFLT xtick, PLINT nxsub,
00391 const char *yopt, PLFLT ytick, PLINT nysub )
00392 {
00393 set_stream();
00394
00395 plbox( xopt, xtick, nxsub, yopt, ytick, nysub );
00396 }
00397
00398
00399
00400
00401 void
00402 plstream::box3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
00403 const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
00404 const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz )
00405 {
00406 set_stream();
00407
00408 plbox3( xopt, xlabel, xtick, nsubx,
00409 yopt, ylabel, ytick, nsuby,
00410 zopt, zlabel, ztick, nsubz );
00411 }
00412
00413
00414 void plstream::btime( PLINT & year, PLINT & month, PLINT & day, PLINT & hour,
00415 PLINT & min, PLFLT & sec, PLFLT ctime )
00416 {
00417 set_stream();
00418
00419 plbtime( &year, &month, &day, &hour, &min, &sec, ctime );
00420 }
00421
00422
00423
00424 void plstream::calc_world( PLFLT rx, PLFLT ry, PLFLT & wx, PLFLT & wy,
00425 PLINT & window )
00426 {
00427 set_stream();
00428
00429 plcalc_world( rx, ry, &wx, &wy, &window );
00430 }
00431
00432
00433
00434 void plstream::clear()
00435 {
00436 set_stream();
00437
00438 plclear();
00439 }
00440
00441
00442
00443 void plstream::col0( PLINT icol0 )
00444 {
00445 set_stream();
00446
00447 plcol0( icol0 );
00448 }
00449
00450
00451
00452 void plstream::col( PLcolor c )
00453 {
00454 set_stream();
00455
00456 plcol0( (int) c );
00457 }
00458
00459
00460
00461 void plstream::col1( PLFLT c )
00462 {
00463 set_stream();
00464
00465 plcol1( c );
00466 }
00467
00468
00469 void plstream::col( PLFLT c )
00470 {
00471 set_stream();
00472
00473 cerr <<
00474 "plstream::col(PLFLT c) : function deprecated. Use plstream::col1(PLFLT c) instead"
00475 << endl;
00476
00477 plcol1( c );
00478 }
00479
00480
00481
00482 void plstream::configtime( PLFLT scale, PLFLT offset1, PLFLT offset2,
00483 PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year,
00484 PLINT month, PLINT day, PLINT hour, PLINT min,
00485 PLFLT sec )
00486 {
00487 set_stream();
00488
00489 plconfigtime( scale, offset1, offset2, ccontrol, ifbtime_offset, year,
00490 month, day, hour, min, sec );
00491 }
00492
00493
00494
00495
00496
00497
00498 void plstream::cont( const PLFLT * const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00499 PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
00500 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00501 PLPointer pltr_data )
00502 {
00503 set_stream();
00504
00505 plcont( (const PLFLT **) f, nx, ny, kx, lx, ky, ly, clevel, nlevel,
00506 pltr, pltr_data );
00507 }
00508
00509
00510
00511
00512
00513 void plstream::fcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
00514 PLPointer f2eval_data,
00515 PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00516 PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
00517 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00518 PLPointer pltr_data )
00519 {
00520 set_stream();
00521
00522 plfcont( f2eval, f2eval_data,
00523 nx, ny, kx, lx, ky, ly, clevel, nlevel,
00524 pltr, pltr_data );
00525 }
00526
00527
00528
00529 void plstream::cpstrm( plstream & pls, bool flags )
00530 {
00531 set_stream();
00532
00533 plcpstrm( pls.stream, (PLBOOL) flags );
00534 }
00535
00536
00537 void plstream::cpstrm( plstream & pls, PLINT flags )
00538 {
00539 set_stream();
00540
00541 plcpstrm( pls.stream, (PLBOOL) flags );
00542 }
00543
00544
00545 void plstream::ctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min,
00546 PLFLT sec, PLFLT & ctime )
00547 {
00548 set_stream();
00549
00550 plctime( year, month, day, hour, min, sec, &ctime );
00551 }
00552
00553
00554
00555
00556 void plstream::did2pc( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
00557 {
00558 set_stream();
00559
00560 pldid2pc( &xmin, &ymin, &xmax, &ymax );
00561 }
00562
00563
00564
00565
00566 void plstream::dip2dc( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
00567 {
00568 set_stream();
00569
00570 pldip2dc( &xmin, &ymin, &xmax, &ymax );
00571 }
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596 void plstream::env( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00597 PLINT just, PLINT axis )
00598 {
00599 set_stream();
00600
00601 plenv( xmin, xmax, ymin, ymax, just, axis );
00602 }
00603
00604
00605
00606
00607 void plstream::env0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00608 PLINT just, PLINT axis )
00609 {
00610 set_stream();
00611
00612 plenv0( xmin, xmax, ymin, ymax, just, axis );
00613 }
00614
00615
00616
00617 void plstream::eop()
00618 {
00619 set_stream();
00620
00621 pleop();
00622 }
00623
00624
00625
00626 void plstream::errx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y )
00627 {
00628 set_stream();
00629
00630 plerrx( n, xmin, xmax, y );
00631 }
00632
00633
00634
00635 void plstream::erry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax )
00636 {
00637 set_stream();
00638
00639 plerry( n, x, ymin, ymax );
00640 }
00641
00642
00643
00644 void plstream::famadv()
00645 {
00646 set_stream();
00647
00648 plfamadv();
00649 }
00650
00651
00652
00653 void plstream::fill( PLINT n, const PLFLT *x, const PLFLT *y )
00654 {
00655
00656
00657 plfill( n, x, y );
00658 }
00659
00660
00661
00662 void plstream::fill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z )
00663 {
00664
00665
00666 plfill3( n, x, y, z );
00667 }
00668
00669
00670
00671 void plstream::flush()
00672 {
00673 set_stream();
00674
00675 ::c_plflush();
00676 }
00677
00678
00679
00680 void plstream::font( PLINT ifont )
00681 {
00682 set_stream();
00683
00684 plfont( ifont );
00685 }
00686
00687
00688
00689 void plstream::fontld( PLINT fnt )
00690 {
00691 set_stream();
00692
00693 plfontld( fnt );
00694 }
00695
00696
00697
00698 void plstream::gchr( PLFLT & p_def, PLFLT & p_ht )
00699 {
00700 set_stream();
00701
00702 plgchr( &p_def, &p_ht );
00703 }
00704
00705
00706
00707 void plstream::gcol0( PLINT icol0, PLINT & r, PLINT & g, PLINT & b )
00708 {
00709 set_stream();
00710
00711 plgcol0( icol0, &r, &g, &b );
00712 }
00713
00714
00715
00716 void plstream::gcol0a( PLINT icol0, PLINT & r, PLINT & g, PLINT & b, PLFLT & a )
00717 {
00718 set_stream();
00719
00720 plgcol0a( icol0, &r, &g, &b, &a );
00721 }
00722
00723
00724
00725 void plstream::gcolbg( PLINT & r, PLINT & g, PLINT & b )
00726 {
00727 set_stream();
00728
00729 plgcolbg( &r, &g, &b );
00730 }
00731
00732
00733
00734 void plstream::gcolbga( PLINT & r, PLINT & g, PLINT & b, PLFLT & a )
00735 {
00736 set_stream();
00737
00738 plgcolbga( &r, &g, &b, &a );
00739 }
00740
00741
00742
00743 void plstream::gcompression( PLINT & compression )
00744 {
00745 set_stream();
00746
00747 plgcompression( &compression );
00748 }
00749
00750
00751
00752 void plstream::gdidev( PLFLT & mar, PLFLT & aspect, PLFLT & jx, PLFLT & jy )
00753 {
00754 set_stream();
00755
00756 plgdidev( &mar, &aspect, &jx, &jy );
00757 }
00758
00759
00760
00761 void plstream::gdiori( PLFLT & rot )
00762 {
00763 set_stream();
00764
00765 plgdiori( &rot );
00766 }
00767
00768
00769
00770 void plstream::gdiplt( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
00771 {
00772 set_stream();
00773
00774 plgdiplt( &xmin, &ymin, &xmax, &ymax );
00775 }
00776
00777
00778
00779 void plstream::gfci( PLUNICODE & pfci )
00780 {
00781 set_stream();
00782
00783 plgfci( &pfci );
00784 }
00785
00786
00787
00788 void plstream::gfam( PLINT & fam, PLINT & num, PLINT & bmax )
00789 {
00790 set_stream();
00791
00792 plgfam( &fam, &num, &bmax );
00793 }
00794
00795
00796
00797 void plstream::gfnam( char *fnam )
00798 {
00799 set_stream();
00800
00801 plgfnam( fnam );
00802 }
00803
00804
00805
00806 void plstream::gfont( PLINT & family, PLINT & style, PLINT & weight )
00807 {
00808 set_stream();
00809
00810 plgfont( &family, &style, &weight );
00811 }
00812
00813
00814
00815 void plstream::glevel( PLINT & level )
00816 {
00817 set_stream();
00818
00819 plglevel( &level );
00820 }
00821
00822
00823
00824 void plstream::gpage( PLFLT & xp, PLFLT & yp, PLINT & xleng, PLINT & yleng,
00825 PLINT & xoff, PLINT & yoff )
00826 {
00827 set_stream();
00828
00829 plgpage( &xp, &yp, &xleng, &yleng, &xoff, &yoff );
00830 }
00831
00832
00833
00834 void plstream::gra()
00835 {
00836 set_stream();
00837
00838 plgra();
00839 }
00840
00841
00842
00843
00844 void plstream::gradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle )
00845 {
00846
00847
00848 plgradient( n, x, y, angle );
00849 }
00850
00851
00852 void plstream::griddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
00853 const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
00854 PLFLT **zg, PLINT type, PLFLT data )
00855 {
00856 set_stream();
00857
00858 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data );
00859 }
00860
00861
00862
00863 void plstream::gspa( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
00864 {
00865 set_stream();
00866
00867 plgspa( &xmin, &xmax, &ymin, &ymax );
00868 }
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883 void plstream::gver( char *p_ver )
00884 {
00885 set_stream();
00886
00887 plgver( p_ver );
00888 }
00889
00890
00891
00892 void plstream::gvpd( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
00893 {
00894 set_stream();
00895
00896 plgvpd( &xmin, &xmax, &ymin, &ymax );
00897 }
00898
00899
00900
00901 void plstream::gvpw( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
00902 {
00903 set_stream();
00904
00905 plgvpw( &xmin, &xmax, &ymin, &ymax );
00906 }
00907
00908
00909
00910 void plstream::gxax( PLINT & digmax, PLINT & digits )
00911 {
00912 set_stream();
00913
00914 plgxax( &digmax, &digits );
00915 }
00916
00917
00918
00919 void plstream::gyax( PLINT & digmax, PLINT & digits )
00920 {
00921 set_stream();
00922
00923 plgyax( &digmax, &digits );
00924 }
00925
00926
00927
00928 void plstream::gzax( PLINT & digmax, PLINT & digits )
00929 {
00930 set_stream();
00931
00932 plgzax( &digmax, &digits );
00933 }
00934
00935
00936
00937 void plstream::hist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
00938 PLINT nbin, PLINT oldwin )
00939 {
00940 set_stream();
00941
00942 plhist( n, data, datmin, datmax, nbin, oldwin );
00943 }
00944
00945
00946
00947 #ifdef PL_DEPRECATED
00948 void plstream::hls( PLFLT h, PLFLT l, PLFLT s )
00949 {
00950 set_stream();
00951
00952 plhls( h, l, s );
00953 }
00954 #endif // PL_DEPRECATED
00955
00956
00957
00958 void plstream::init()
00959 {
00960 set_stream();
00961
00962 plinit();
00963
00964 plgstrm( &stream );
00965
00966
00967
00968 }
00969
00970
00971
00972 void plstream::join( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 )
00973 {
00974 set_stream();
00975
00976 pljoin( x1, y1, x2, y2 );
00977 }
00978
00979
00980
00981 void plstream::lab( const char *xlabel, const char *ylabel,
00982 const char *tlabel )
00983 {
00984 set_stream();
00985
00986 pllab( xlabel, ylabel, tlabel );
00987 }
00988
00989
00990
00991 void plstream::legend( PLFLT *p_legend_width, PLFLT *p_legend_height,
00992 PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
00993 PLINT bg_color, PLINT bb_color, PLINT bb_style,
00994 PLINT nrow, PLINT ncolumn,
00995 PLINT nlegend, const PLINT *opt_array,
00996 PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
00997 PLFLT text_justification,
00998 const PLINT *text_colors, const char **text,
00999 const PLINT *box_colors, const PLINT *box_patterns,
01000 const PLFLT *box_scales, const PLINT *box_line_widths,
01001 const PLINT *line_colors, const PLINT *line_styles,
01002 const PLINT *line_widths,
01003 const PLINT *symbol_colors, const PLFLT *symbol_scales,
01004 const PLINT *symbol_numbers, const char **symbols )
01005 {
01006 set_stream();
01007
01008 pllegend( p_legend_width, p_legend_height, opt, position, x, y, plot_width,
01009 bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array,
01010 text_offset, text_scale, text_spacing, text_justification,
01011 text_colors, text, box_colors, box_patterns, box_scales,
01012 box_line_widths, line_colors, line_styles, line_widths,
01013 symbol_colors, symbol_scales, symbol_numbers, symbols );
01014 }
01015
01016 void plstream::colorbar( PLINT position, PLINT opt, PLFLT x, PLFLT y, PLFLT length, PLFLT width, PLINT cont_color, PLINT cont_width,
01017 PLFLT ticks, PLINT sub_ticks,
01018 const char *axis_opts, const char *label,
01019 PLINT n_colors, const PLFLT *colors, const PLFLT *values )
01020 {
01021 set_stream();
01022
01023 #if 0
01024 plcolorbar( position, opt, x, y, length, width,
01025 cont_color, cont_width, ticks, sub_ticks, axis_opts,
01026 label, n_colors, colors, values );
01027 #endif
01028 }
01029
01030
01031
01032
01033 void plstream::lightsource( PLFLT x, PLFLT y, PLFLT z )
01034 {
01035 set_stream();
01036
01037 pllightsource( x, y, z );
01038 }
01039
01040
01041
01042 void plstream::line( PLINT n, const PLFLT *x, const PLFLT *y )
01043 {
01044 set_stream();
01045
01046 plline( n, x, y );
01047 }
01048
01049
01050
01051 void plstream::line3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z )
01052 {
01053 set_stream();
01054
01055 plline3( n, x, y, z );
01056 }
01057
01058
01059
01060 void plstream::lsty( PLINT lin )
01061 {
01062 set_stream();
01063
01064 pllsty( lin );
01065 }
01066
01067
01068
01069 void plstream::map( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
01070 const char *type, PLFLT minlong, PLFLT maxlong,
01071 PLFLT minlat, PLFLT maxlat )
01072 {
01073 set_stream();
01074
01075 plmap( mapform, type, minlong, maxlong, minlat, maxlat );
01076 }
01077
01078
01079
01080 void plstream::meridians( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
01081 PLFLT dlong, PLFLT dlat,
01082 PLFLT minlong, PLFLT maxlong,
01083 PLFLT minlat, PLFLT maxlat )
01084 {
01085 set_stream();
01086
01087 plmeridians( mapform, dlong, dlat, minlong, maxlong, minlat,
01088 maxlat );
01089 }
01090
01091
01092
01093 void plstream::mesh( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny,
01094 PLINT opt )
01095 {
01096 set_stream();
01097
01098 plmesh( x, y, (const PLFLT **) z, nx, ny, opt );
01099 }
01100
01101
01102
01103 void plstream::meshc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny,
01104 PLINT opt, const PLFLT *clevel, PLINT nlevel )
01105 {
01106 set_stream();
01107
01108 plmeshc( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel );
01109 }
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122 void plstream::mtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
01123 const char *text )
01124 {
01125 set_stream();
01126
01127 plmtex( side, disp, pos, just, text );
01128 }
01129
01130
01131
01132 void plstream::mtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
01133 const char *text )
01134 {
01135 set_stream();
01136
01137 plmtex3( side, disp, pos, just, text );
01138 }
01139
01140
01141
01142 void plstream::surf3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01143 PLINT nx, PLINT ny, PLINT opt,
01144 const PLFLT *clevel, PLINT nlevel )
01145 {
01146 set_stream();
01147
01148 plsurf3d( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel );
01149 }
01150
01151
01152
01153
01154 void plstream::surf3dl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01155 PLINT nx, PLINT ny, PLINT opt,
01156 const PLFLT *clevel, PLINT nlevel,
01157 PLINT ixstart, PLINT ixn,
01158 const PLINT *indexymin, const PLINT *indexymax )
01159 {
01160 set_stream();
01161
01162 plsurf3dl( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel, ixstart, ixn,
01163 indexymin, indexymax );
01164 }
01165
01166
01167
01168 void plstream::plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01169 PLINT nx, PLINT ny, PLINT opt, bool side )
01170 {
01171 set_stream();
01172
01173 ::plot3d( x, y, (const PLFLT **) z, nx, ny, opt, (PLBOOL) side );
01174 }
01175
01176
01177 void plstream::plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01178 PLINT nx, PLINT ny, PLINT opt, PLINT side )
01179 {
01180 set_stream();
01181
01182 ::plot3d( x, y, (const PLFLT **) z, nx, ny, opt, (PLBOOL) side );
01183 }
01184
01185
01186
01187 void plstream::plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01188 PLINT nx, PLINT ny, PLINT opt,
01189 const PLFLT *clevel, PLINT nlevel )
01190 {
01191 set_stream();
01192
01193 ::plot3dc( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel );
01194 }
01195
01196
01197
01198
01199 void plstream::plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01200 PLINT nx, PLINT ny, PLINT opt,
01201 const PLFLT *clevel, PLINT nlevel,
01202 PLINT ixstart, PLINT ixn,
01203 const PLINT *indexymin, const PLINT *indexymax )
01204 {
01205 set_stream();
01206
01207 ::plot3dcl( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel, ixstart, ixn,
01208 indexymin, indexymax );
01209 }
01210
01211
01212
01213 int plstream::parseopts( int *p_argc, const char **argv, PLINT mode )
01214 {
01215 set_stream();
01216
01217 return ::plparseopts( p_argc, argv, mode );
01218 }
01219
01220
01221
01222 void plstream::pat( PLINT nlin, const PLINT *inc, const PLINT *del )
01223 {
01224 set_stream();
01225
01226 plpat( nlin, inc, del );
01227 }
01228
01229
01230
01231 void plstream::poin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code )
01232 {
01233 set_stream();
01234
01235 plpoin( n, x, y, code );
01236 }
01237
01238
01239
01240 void plstream::poin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code )
01241 {
01242 set_stream();
01243
01244 plpoin3( n, x, y, z, code );
01245 }
01246
01247
01248
01249 void plstream::poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z,
01250 const bool *draw, bool ifcc )
01251 {
01252 PLBOOL *loc_draw = new PLBOOL[n - 1];
01253 for ( int i = 0; i < n - 1; i++ )
01254 {
01255 loc_draw[i] = (PLBOOL) draw[i];
01256 }
01257
01258 set_stream();
01259
01260 plpoly3( n, x, y, z, loc_draw, (PLBOOL) ifcc );
01261
01262 delete [] loc_draw;
01263 }
01264
01265
01266 void plstream::poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z,
01267 const PLINT *draw, PLINT ifcc )
01268 {
01269 PLBOOL *loc_draw = new PLBOOL[n - 1];
01270 for ( int i = 0; i < n - 1; i++ )
01271 {
01272 loc_draw[i] = (PLBOOL) draw[i];
01273 }
01274
01275 set_stream();
01276
01277 plpoly3( n, x, y, z, loc_draw, (PLBOOL) ifcc );
01278
01279 delete [] loc_draw;
01280 }
01281
01282
01283
01284 void plstream::prec( PLINT setp, PLINT prec )
01285 {
01286 set_stream();
01287
01288 plprec( setp, prec );
01289 }
01290
01291
01292
01293 void plstream::psty( PLINT patt )
01294 {
01295 set_stream();
01296
01297 plpsty( patt );
01298 }
01299
01300
01301
01302 void plstream::ptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just,
01303 const char *text )
01304 {
01305 set_stream();
01306
01307 plptex( x, y, dx, dy, just, text );
01308 }
01309
01310
01311
01312 void plstream::ptex3( PLFLT wx, PLFLT wy, PLFLT wz,
01313 PLFLT dx, PLFLT dy, PLFLT dz,
01314 PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just,
01315 const char *text )
01316 {
01317 set_stream();
01318
01319 plptex3( wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text );
01320 }
01321
01322
01323
01324 void plstream::replot()
01325 {
01326 set_stream();
01327
01328 plreplot();
01329 }
01330
01331
01332
01333 #ifdef PL_DEPRECATED
01334 void plstream::rgb( PLFLT r, PLFLT g, PLFLT b )
01335 {
01336 set_stream();
01337
01338 plrgb( r, g, b );
01339 }
01340 #endif // PL_DEPRECATED
01341
01342
01343
01344 #ifdef PL_DEPRECATED
01345 void plstream::rgb( PLINT r, PLINT g, PLINT b )
01346 {
01347 set_stream();
01348
01349 plrgb1( r, g, b );
01350 }
01351 #endif // PL_DEPRECATED
01352
01353
01354
01355 void plstream::schr( PLFLT def, PLFLT scale )
01356 {
01357 set_stream();
01358
01359 plschr( def, scale );
01360 }
01361
01362
01363
01364 void plstream::scmap0n( PLINT ncol0 )
01365 {
01366 set_stream();
01367
01368 plscmap0n( ncol0 );
01369 }
01370
01371
01372
01373 void plstream::scmap1n( PLINT ncol1 )
01374 {
01375 set_stream();
01376
01377 plscmap1n( ncol1 );
01378 }
01379
01380
01381
01382 void plstream::scmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 )
01383 {
01384 set_stream();
01385
01386 plscmap0( r, g, b, ncol0 );
01387 }
01388
01389
01390
01391 void plstream::scmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 )
01392 {
01393 set_stream();
01394
01395 plscmap0a( r, g, b, a, ncol0 );
01396 }
01397
01398
01399
01400 void plstream::scmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 )
01401 {
01402 set_stream();
01403
01404 plscmap1( r, g, b, ncol1 );
01405 }
01406
01407
01408
01409 void plstream::scmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 )
01410 {
01411 set_stream();
01412
01413 plscmap1a( r, g, b, a, ncol1 );
01414 }
01415
01416
01417
01418
01419 void plstream::scmap1l( bool itype, PLINT npts, const PLFLT *intensity,
01420 const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
01421 const bool *rev )
01422 {
01423 PLBOOL *loc_rev = NULL;
01424 if ( rev != NULL )
01425 {
01426 loc_rev = new PLBOOL[npts - 1];
01427 for ( int i = 0; i < npts - 1; i++ )
01428 {
01429 loc_rev[i] = (PLBOOL) rev[i];
01430 }
01431 }
01432
01433 set_stream();
01434
01435 plscmap1l( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3, loc_rev );
01436
01437 if ( loc_rev != NULL )
01438 delete [] loc_rev;
01439 }
01440
01441
01442
01443
01444
01445 void plstream::scmap1la( bool itype, PLINT npts, const PLFLT *intensity,
01446 const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
01447 const PLFLT *a, const bool *rev )
01448 {
01449 PLBOOL *loc_rev = NULL;
01450 if ( rev != NULL )
01451 {
01452 loc_rev = new PLBOOL[npts - 1];
01453 for ( int i = 0; i < npts - 1; i++ )
01454 {
01455 loc_rev[i] = (PLBOOL) rev[i];
01456 }
01457 }
01458
01459 set_stream();
01460
01461 plscmap1la( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3,
01462 a, loc_rev );
01463
01464 if ( loc_rev != NULL )
01465 delete [] loc_rev;
01466 }
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479 void plstream::scmap1l( PLINT itype, PLINT npts, const PLFLT *intensity,
01480 const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
01481 const PLINT *rev )
01482 {
01483 PLBOOL *loc_rev = NULL;
01484 if ( rev != NULL )
01485 {
01486 loc_rev = new PLBOOL[npts - 1];
01487 for ( int i = 0; i < npts - 1; i++ )
01488 {
01489 loc_rev[i] = (PLBOOL) rev[i];
01490 }
01491 }
01492
01493 set_stream();
01494
01495 plscmap1l( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3, loc_rev );
01496
01497 if ( loc_rev != NULL )
01498 delete [] loc_rev;
01499 }
01500
01501
01502
01503 void plstream::scol0( PLINT icol0, PLINT r, PLINT g, PLINT b )
01504 {
01505 set_stream();
01506
01507 plscol0( icol0, r, g, b );
01508 }
01509
01510
01511
01512 void plstream::scol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a )
01513 {
01514 set_stream();
01515
01516 plscol0a( icol0, r, g, b, a );
01517 }
01518
01519
01520
01521 void plstream::scolbg( PLINT r, PLINT g, PLINT b )
01522 {
01523 set_stream();
01524
01525 plscolbg( r, g, b );
01526 }
01527
01528
01529
01530 void plstream::scolbga( PLINT r, PLINT g, PLINT b, PLFLT a )
01531 {
01532 set_stream();
01533
01534 plscolbga( r, g, b, a );
01535 }
01536
01537
01538
01539 void plstream::scolor( PLINT color )
01540 {
01541 set_stream();
01542
01543 plscolor( color );
01544 }
01545
01546
01547
01548 void plstream::scompression( PLINT compression )
01549 {
01550 set_stream();
01551
01552 plscompression( compression );
01553 }
01554
01555
01556
01557 void plstream::sdev( const char *devname )
01558 {
01559 set_stream();
01560
01561 plsdev( devname );
01562 }
01563
01564
01565
01566 void plstream::gdev( char *devname )
01567 {
01568 set_stream();
01569
01570 plgdev( devname );
01571 }
01572
01573
01574
01575
01576 void plstream::sdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy )
01577 {
01578 set_stream();
01579
01580 plsdidev( mar, aspect, jx, jy );
01581 }
01582
01583
01584
01585 void plstream::sdimap( PLINT dimxmin, PLINT dimxmax,
01586 PLINT dimymin, PLINT dimymax,
01587 PLFLT dimxpmm, PLFLT dimypmm )
01588 {
01589 set_stream();
01590
01591 plsdimap( dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm );
01592 }
01593
01594
01595
01596 void plstream::sdiori( PLFLT rot )
01597 {
01598 set_stream();
01599
01600 plsdiori( rot );
01601 }
01602
01603
01604
01605 void plstream::sdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax )
01606 {
01607 set_stream();
01608
01609 plsdiplt( xmin, ymin, xmax, ymax );
01610 }
01611
01612
01613
01614 void plstream::sdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax )
01615 {
01616 set_stream();
01617
01618 plsdiplz( xmin, ymin, xmax, ymax );
01619 }
01620
01621
01622
01623 void plstream::sesc( char esc )
01624 {
01625 set_stream();
01626
01627 plsesc( esc );
01628 }
01629
01630
01631
01632 void plstream::setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing,
01633 PLINT active )
01634 {
01635 set_stream();
01636
01637 pl_setcontlabelparam( offset, size, spacing, active );
01638 }
01639
01640
01641
01642 void plstream::setcontlabelformat( PLINT lexp, PLINT sigdig )
01643 {
01644 set_stream();
01645
01646 pl_setcontlabelformat( lexp, sigdig );
01647 }
01648
01649
01650
01651 void plstream::sfam( PLINT fam, PLINT num, PLINT bmax )
01652 {
01653 set_stream();
01654
01655 plsfam( fam, num, bmax );
01656 }
01657
01658
01659
01660 void plstream::sfci( PLUNICODE fci )
01661 {
01662 set_stream();
01663
01664 plsfci( fci );
01665 }
01666
01667
01668
01669 void plstream::sfnam( const char *fnam )
01670 {
01671 set_stream();
01672
01673 plsfnam( fnam );
01674 }
01675
01676
01677
01678 void plstream::sfont( PLINT family, PLINT style, PLINT weight )
01679 {
01680 set_stream();
01681
01682 plsfont( family, style, weight );
01683 }
01684
01685
01686
01687 void
01688 plstream::shade( const PLFLT * const *a, PLINT nx, PLINT ny,
01689 PLINT ( *defined )( PLFLT, PLFLT ),
01690 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01691 PLFLT shade_min, PLFLT shade_max,
01692 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01693 PLINT min_color, PLINT min_width,
01694 PLINT max_color, PLINT max_width,
01695 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01696 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01697 PLPointer pltr_data )
01698 {
01699 set_stream();
01700
01701 plshade( (const PLFLT **) a, nx, ny, defined, left, right, bottom, top,
01702 shade_min, shade_max,
01703 sh_cmap, sh_color, sh_width,
01704 min_color, min_width, max_color, max_width,
01705 fill, (PLBOOL) rectangular, pltr, pltr_data );
01706 }
01707
01708
01709 void
01710 plstream::shade( const PLFLT * const *a, PLINT nx, PLINT ny,
01711 PLINT ( *defined )( PLFLT, PLFLT ),
01712 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01713 PLFLT shade_min, PLFLT shade_max,
01714 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01715 PLINT min_color, PLINT min_width,
01716 PLINT max_color, PLINT max_width,
01717 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01718 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01719 PLPointer pltr_data )
01720 {
01721 set_stream();
01722
01723 plshade( (const PLFLT **) a, nx, ny, defined, left, right, bottom, top,
01724 shade_min, shade_max,
01725 sh_cmap, sh_color, sh_width,
01726 min_color, min_width, max_color, max_width,
01727 fill, (PLBOOL) rectangular, pltr, pltr_data );
01728 }
01729
01730 void
01731 plstream::shades( const PLFLT * const *a, PLINT nx, PLINT ny,
01732 PLINT ( *defined )( PLFLT, PLFLT ),
01733 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01734 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
01735 PLINT cont_color, PLINT cont_width,
01736 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01737 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01738 PLPointer pltr_data )
01739 {
01740 set_stream();
01741
01742 plshades( (const PLFLT **) a, nx, ny, defined, xmin, xmax, ymin, ymax,
01743 clevel, nlevel, fill_width, cont_color, cont_width,
01744 fill, (PLBOOL) rectangular, pltr, pltr_data );
01745 }
01746
01747
01748 void
01749 plstream::shades( const PLFLT * const *a, PLINT nx, PLINT ny,
01750 PLINT ( *defined )( PLFLT, PLFLT ),
01751 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01752 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
01753 PLINT cont_color, PLINT cont_width,
01754 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01755 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01756 PLPointer pltr_data )
01757 {
01758 set_stream();
01759
01760 plshades( (const PLFLT **) a, nx, ny, defined, xmin, xmax, ymin, ymax,
01761 clevel, nlevel, fill_width, cont_color, cont_width,
01762 fill, (PLBOOL) rectangular, pltr, pltr_data );
01763 }
01764
01765 void
01766 plstream::shade( Contourable_Data & d, PLFLT xmin, PLFLT xmax,
01767 PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
01768 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01769 PLINT min_color, PLINT min_width,
01770 PLINT max_color, PLINT max_width,
01771 bool rectangular,
01772 Coord_Xformer *pcxf )
01773 {
01774 set_stream();
01775
01776 int nx, ny;
01777 d.elements( nx, ny );
01778
01779 if ( pcxf != NULL )
01780 ::plfshade( Contourable_Data_evaluator, &d,
01781 NULL, NULL,
01782 nx, ny,
01783 xmin, xmax, ymin, ymax, shade_min, shade_max,
01784 sh_cmap, sh_color, sh_width,
01785 min_color, min_width, max_color, max_width,
01786 ::plfill, rectangular,
01787 Coord_Xform_evaluator, pcxf );
01788 else
01789 ::plfshade( Contourable_Data_evaluator, &d,
01790 NULL, NULL,
01791 nx, ny,
01792 xmin, xmax, ymin, ymax, shade_min, shade_max,
01793 sh_cmap, sh_color, sh_width,
01794 min_color, min_width, max_color, max_width,
01795 ::plfill, rectangular,
01796 NULL, NULL );
01797 }
01798
01799
01800 void
01801 plstream::shade( Contourable_Data & d, PLFLT xmin, PLFLT xmax,
01802 PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
01803 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01804 PLINT min_color, PLINT min_width,
01805 PLINT max_color, PLINT max_width,
01806 PLINT rectangular,
01807 Coord_Xformer *pcxf )
01808 {
01809 set_stream();
01810
01811 int nx, ny;
01812 d.elements( nx, ny );
01813
01814 ::plfshade( Contourable_Data_evaluator, &d,
01815 NULL, NULL,
01816 nx, ny,
01817 xmin, xmax, ymin, ymax, shade_min, shade_max,
01818 sh_cmap, sh_color, sh_width,
01819 min_color, min_width, max_color, max_width,
01820 ::plfill, rectangular != 0,
01821 Coord_Xform_evaluator, pcxf );
01822 }
01823
01824 void
01825 plstream::shade1( const PLFLT *a, PLINT nx, PLINT ny,
01826 PLINT ( *defined )( PLFLT, PLFLT ),
01827 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01828 PLFLT shade_min, PLFLT shade_max,
01829 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01830 PLINT min_color, PLINT min_width,
01831 PLINT max_color, PLINT max_width,
01832 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01833 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01834 PLPointer pltr_data )
01835 {
01836 set_stream();
01837
01838 plshade1( a, nx, ny, defined,
01839 left, right, bottom, top,
01840 shade_min, shade_max,
01841 sh_cmap, sh_color, sh_width,
01842 min_color, min_width, max_color, max_width,
01843 fill, (PLBOOL) rectangular, pltr, pltr_data );
01844 }
01845
01846
01847 void
01848 plstream::shade1( const PLFLT *a, PLINT nx, PLINT ny,
01849 PLINT ( *defined )( PLFLT, PLFLT ),
01850 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01851 PLFLT shade_min, PLFLT shade_max,
01852 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01853 PLINT min_color, PLINT min_width,
01854 PLINT max_color, PLINT max_width,
01855 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01856 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01857 PLPointer pltr_data )
01858 {
01859 set_stream();
01860
01861 plshade1( a, nx, ny, defined,
01862 left, right, bottom, top,
01863 shade_min, shade_max,
01864 sh_cmap, sh_color, sh_width,
01865 min_color, min_width, max_color, max_width,
01866 fill, (PLBOOL) rectangular, pltr, pltr_data );
01867 }
01868
01869 void
01870 plstream::fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
01871 PLPointer f2eval_data,
01872 PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
01873 PLPointer c2eval_data,
01874 PLINT nx, PLINT ny,
01875 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01876 PLFLT shade_min, PLFLT shade_max,
01877 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01878 PLINT min_color, PLINT min_width,
01879 PLINT max_color, PLINT max_width,
01880 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01881 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01882 PLPointer pltr_data )
01883 {
01884 set_stream();
01885
01886 plfshade( f2eval, f2eval_data,
01887 c2eval, c2eval_data,
01888 nx, ny, left, right, bottom, top,
01889 shade_min, shade_max,
01890 sh_cmap, sh_color, sh_width,
01891 min_color, min_width, max_color, max_width,
01892 fill, (PLBOOL) rectangular, pltr, pltr_data );
01893 }
01894
01895
01896 void
01897 plstream::fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
01898 PLPointer f2eval_data,
01899 PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
01900 PLPointer c2eval_data,
01901 PLINT nx, PLINT ny,
01902 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01903 PLFLT shade_min, PLFLT shade_max,
01904 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01905 PLINT min_color, PLINT min_width,
01906 PLINT max_color, PLINT max_width,
01907 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01908 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01909 PLPointer pltr_data )
01910 {
01911 set_stream();
01912
01913 plfshade( f2eval, f2eval_data,
01914 c2eval, c2eval_data,
01915 nx, ny, left, right, bottom, top,
01916 shade_min, shade_max,
01917 sh_cmap, sh_color, sh_width,
01918 min_color, min_width, max_color, max_width,
01919 fill, (PLBOOL) rectangular, pltr, pltr_data );
01920 }
01921
01922
01923
01924 void plstream::slabelfunc( void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer ),
01925 PLPointer label_data )
01926 {
01927 set_stream();
01928
01929 plslabelfunc( label_func, label_data );
01930 }
01931
01932
01933
01934 void plstream::smaj( PLFLT def, PLFLT scale )
01935 {
01936 set_stream();
01937
01938 plsmaj( def, scale );
01939 }
01940
01941
01942
01943 void plstream::smem( PLINT maxx, PLINT maxy, void *plotmem )
01944 {
01945 set_stream();
01946
01947 plsmem( maxx, maxy, plotmem );
01948 }
01949
01950
01951
01952 void plstream::smema( PLINT maxx, PLINT maxy, void *plotmem )
01953 {
01954 set_stream();
01955
01956 plsmema( maxx, maxy, plotmem );
01957 }
01958
01959
01960
01961 void plstream::smin( PLFLT def, PLFLT scale )
01962 {
01963 set_stream();
01964
01965 plsmin( def, scale );
01966 }
01967
01968
01969
01970 void plstream::sori( PLINT ori )
01971 {
01972 set_stream();
01973
01974 plsori( ori );
01975 }
01976
01977
01978
01979 void plstream::spage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
01980 PLINT xoff, PLINT yoff )
01981 {
01982 set_stream();
01983
01984 plspage( xp, yp, xleng, yleng, xoff, yoff );
01985 }
01986
01987
01988
01989 void plstream::spal0( const char *filename )
01990 {
01991 set_stream();
01992
01993 plspal0( filename );
01994 }
01995
01996
01997
01998 void plstream::spal1( const char *filename, bool interpolate )
01999 {
02000 set_stream();
02001
02002 plspal1( filename, (PLBOOL) interpolate );
02003 }
02004
02005
02006
02007 void plstream::spause( bool pause )
02008 {
02009 set_stream();
02010
02011 plspause( (PLBOOL) pause );
02012 }
02013
02014
02015 void plstream::spause( PLINT pause )
02016 {
02017 set_stream();
02018
02019 plspause( (PLBOOL) pause );
02020 }
02021
02022
02023
02024 void plstream::sstrm( PLINT strm )
02025 {
02026 set_stream();
02027
02028 plsstrm( strm );
02029 }
02030
02031
02032
02033 void plstream::ssub( PLINT nx, PLINT ny )
02034 {
02035 set_stream();
02036
02037 plssub( nx, ny );
02038 }
02039
02040
02041
02042 void plstream::ssym( PLFLT def, PLFLT scale )
02043 {
02044 set_stream();
02045
02046 plssym( def, scale );
02047 }
02048
02049
02050
02051 void plstream::star( PLINT nx, PLINT ny )
02052 {
02053 set_stream();
02054
02055 plstar( nx, ny );
02056 }
02057
02058
02059
02060 void plstream::start( const char *devname, PLINT nx, PLINT ny )
02061 {
02062 set_stream();
02063
02064 plstart( devname, nx, ny );
02065 }
02066
02067
02068
02069 void plstream::stransform( void ( *coordinate_transform )( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ),
02070 PLPointer coordinate_transform_data )
02071 {
02072 set_stream();
02073
02074 plstransform( coordinate_transform, coordinate_transform_data );
02075 }
02076
02077
02078
02079
02080
02081
02082
02083 void plstream::string( PLINT n, const PLFLT *x, const PLFLT *y, const char *string )
02084 {
02085 set_stream();
02086 plstring( n, x, y, string );
02087 }
02088
02089
02090
02091
02092
02093
02094
02095 void plstream::string3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string )
02096 {
02097 set_stream();
02098 plstring3( n, x, y, z, string );
02099 }
02100
02101
02102
02103 void plstream::stripc( PLINT *id, const char *xspec, const char *yspec,
02104 PLFLT xmin, PLFLT xmax, PLFLT xjump,
02105 PLFLT ymin, PLFLT ymax,
02106 PLFLT xlpos, PLFLT ylpos, bool y_ascl,
02107 bool acc, PLINT colbox, PLINT collab,
02108 const PLINT colline[], const PLINT styline[],
02109 const char *legline[], const char *labx,
02110 const char *laby, const char *labtop )
02111 {
02112 set_stream();
02113
02114 plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos,
02115 (PLBOOL) y_ascl, (PLBOOL) acc, colbox, collab, colline, styline,
02116 legline, labx, laby, labtop );
02117 }
02118
02119
02120
02121 void plstream::stripc( PLINT *id, const char *xspec, const char *yspec,
02122 PLFLT xmin, PLFLT xmax, PLFLT xjump,
02123 PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos,
02124 PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab,
02125 const PLINT colline[], const PLINT styline[],
02126 const char *legline[], const char *labx,
02127 const char *laby, const char *labtop )
02128 {
02129 set_stream();
02130
02131 plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos,
02132 (PLBOOL) y_ascl, (PLBOOL) acc, colbox, collab, colline, styline,
02133 legline, labx, laby, labtop );
02134 }
02135
02136
02137
02138 void plstream::stripa( PLINT id, PLINT pen, PLFLT x, PLFLT y )
02139 {
02140 set_stream();
02141
02142 plstripa( id, pen, x, y );
02143 }
02144
02145
02146
02147 void plstream::stripd( PLINT id )
02148 {
02149 set_stream();
02150
02151 plstripd( id );
02152 }
02153
02154
02155
02156
02157 void plstream::image( const PLFLT * const *data, PLINT nx, PLINT ny,
02158 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
02159 PLFLT zmin, PLFLT zmax,
02160 PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax )
02161 {
02162 set_stream();
02163
02164 plimage( (const PLFLT **) data, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
02165 Dxmin, Dxmax, Dymin, Dymax );
02166 }
02167
02168
02169
02170 void plstream::imagefr( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
02171 PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
02172 PLFLT valuemin, PLFLT valuemax,
02173 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
02174 PLPointer pltr_data )
02175 {
02176 set_stream();
02177
02178 plimagefr( (const PLFLT **) data, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
02179 valuemin, valuemax, pltr, pltr_data );
02180 }
02181
02182
02183
02184 void plstream::styl( PLINT nms, const PLINT *mark, const PLINT *space )
02185 {
02186 set_stream();
02187
02188 plstyl( nms, mark, space );
02189 }
02190
02191
02192
02193 void plstream::svpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
02194 {
02195 set_stream();
02196
02197 plsvpa( xmin, xmax, ymin, ymax );
02198 }
02199
02200
02201
02202 void plstream::sxax( PLINT digmax, PLINT digits )
02203 {
02204 set_stream();
02205
02206 plsxax( digmax, digits );
02207 }
02208
02209
02210
02211 void plstream::sxwin( PLINT window_id )
02212 {
02213 set_stream();
02214
02215 plsxwin( window_id );
02216 }
02217
02218
02219
02220 void plstream::syax( PLINT digmax, PLINT digits )
02221 {
02222 set_stream();
02223
02224 plsyax( digmax, digits );
02225 }
02226
02227
02228
02229 void plstream::sym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code )
02230 {
02231 set_stream();
02232
02233 plsym( n, x, y, code );
02234 }
02235
02236
02237
02238 void plstream::szax( PLINT digmax, PLINT digits )
02239 {
02240 set_stream();
02241
02242 plszax( digmax, digits );
02243 }
02244
02245
02246
02247 void plstream::text()
02248 {
02249 set_stream();
02250
02251 pltext();
02252 }
02253
02254
02255
02256 void plstream::timefmt( const char *fmt )
02257 {
02258 set_stream();
02259
02260 pltimefmt( fmt );
02261 }
02262
02263
02264
02265
02266 void plstream::vasp( PLFLT aspect )
02267 {
02268 set_stream();
02269
02270 plvasp( aspect );
02271 }
02272
02273
02274
02275
02276 void plstream::vpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
02277 PLFLT aspect )
02278 {
02279 set_stream();
02280
02281 plvpas( xmin, xmax, ymin, ymax, aspect );
02282 }
02283
02284
02285
02286 void plstream::vpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
02287 {
02288 set_stream();
02289
02290 plvpor( xmin, xmax, ymin, ymax );
02291 }
02292
02293
02294
02295
02296 void plstream::vsta()
02297 {
02298 set_stream();
02299
02300 plvsta();
02301 }
02302
02303
02304
02305 void plstream::w3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
02306 PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
02307 PLFLT zmax0, PLFLT alt, PLFLT az )
02308 {
02309 set_stream();
02310
02311 plw3d( basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0,
02312 alt, az );
02313 }
02314
02315
02316
02317 void plstream::wid( PLINT width )
02318 {
02319 set_stream();
02320
02321 plwid( width );
02322 }
02323
02324
02325
02326 void plstream::wind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
02327 {
02328 set_stream();
02329
02330 plwind( xmin, xmax, ymin, ymax );
02331 }
02332
02333
02334
02335 void plstream::xormod( bool mode, bool *status )
02336 {
02337 PLBOOL loc_status;
02338
02339 set_stream();
02340
02341 plxormod( (PLBOOL) mode, &loc_status );
02342
02343 *status = ( loc_status != 0 );
02344 }
02345
02346
02347 void plstream::xormod( PLINT mode, PLINT *status )
02348 {
02349 PLBOOL loc_status;
02350
02351 set_stream();
02352
02353 plxormod( (PLBOOL) mode, &loc_status );
02354
02355 *status = (PLINT) loc_status;
02356 }
02357
02358
02359
02360 void plstream::seed( unsigned int s )
02361 {
02362 set_stream();
02363
02364 plseed( s );
02365 }
02366
02367
02368
02369 PLFLT plstream::randd( void )
02370 {
02371 set_stream();
02372
02373 return plrandd();
02374 }
02375
02376
02377
02378
02379
02380 void plstream::gFileDevs( const char ***p_menustr, const char ***p_devname,
02381 int *p_ndev )
02382 {
02383 set_stream();
02384
02385 plgFileDevs( p_menustr, p_devname, p_ndev );
02386 }
02387
02388
02389
02390 void plstream::sKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ),
02391 void *KeyEH_data )
02392 {
02393 set_stream();
02394
02395 plsKeyEH( KeyEH, KeyEH_data );
02396 }
02397
02398
02399
02400 void plstream::sError( PLINT *errcode, char *errmsg )
02401 {
02402 set_stream();
02403
02404 plsError( errcode, errmsg );
02405 }
02406
02407
02408
02409 void plstream::sexit( int ( *handler )( const char * ) )
02410 {
02411 set_stream();
02412
02413 plsexit( handler );
02414 }
02415
02416
02417
02418
02419
02420 void plstream::tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02421 PLPointer pltr_data )
02422 {
02423 pltr0( x, y, tx, ty, pltr_data );
02424 }
02425
02426
02427
02428 void plstream::tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02429 PLPointer pltr_data )
02430 {
02431 pltr1( x, y, tx, ty, pltr_data );
02432 }
02433
02434
02435
02436
02437 void plstream::tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02438 PLPointer pltr_data )
02439 {
02440 pltr2( x, y, tx, ty, pltr_data );
02441 }
02442
02443
02444
02445
02446 void plstream::tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02447 PLPointer pltr_data )
02448 {
02449 pltr2p( x, y, tx, ty, pltr_data );
02450 }
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487 PLFLT plstream::f2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data )
02488 {
02489 set_stream();
02490
02491 return ::plf2eval2( ix, iy, plf2eval_data );
02492 }
02493
02494
02495
02496
02497 PLFLT plstream::f2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data )
02498 {
02499 set_stream();
02500
02501 return ::plf2eval( ix, iy, plf2eval_data );
02502 }
02503
02504
02505
02506
02507 PLFLT plstream::f2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data )
02508 {
02509 set_stream();
02510
02511 return ::plf2evalr( ix, iy, plf2eval_data );
02512 }
02513
02514
02515
02516
02517
02518 void plstream::ClearOpts()
02519 {
02520 set_stream();
02521
02522 ::plClearOpts();
02523 }
02524
02525
02526
02527 void plstream::ResetOpts()
02528 {
02529 set_stream();
02530
02531 ::plResetOpts();
02532 }
02533
02534
02535
02536 int plstream::MergeOpts( PLOptionTable *options, const char *name,
02537 const char **notes )
02538 {
02539 set_stream();
02540
02541 return ::plMergeOpts( options, name, notes );
02542 }
02543
02544
02545
02546 void plstream::SetUsage( char *program_string, char *usage_string )
02547 {
02548 set_stream();
02549
02550 ::plSetUsage( program_string, usage_string );
02551 }
02552
02553
02554
02555 int plstream::setopt( const char *opt, const char *optarg )
02556 {
02557 set_stream();
02558
02559 return ::plsetopt( opt, optarg );
02560 }
02561
02562
02563 #ifdef PL_DEPRECATED
02564 int plstream::SetOpt( const char *opt, const char *optarg )
02565 {
02566 set_stream();
02567
02568 return ::plsetopt( opt, optarg );
02569 }
02570 #endif // PL_DEPRECATED
02571
02572
02573
02574 void plstream::OptUsage()
02575 {
02576 set_stream();
02577
02578 ::plOptUsage();
02579 }
02580
02581
02582
02583
02584
02585 void plstream::gfile( FILE **p_file )
02586 {
02587 set_stream();
02588
02589 ::plgfile( p_file );
02590 }
02591
02592
02593
02594 void plstream::sfile( FILE *file )
02595 {
02596 set_stream();
02597
02598 ::plsfile( file );
02599 }
02600
02601
02602
02603
02604 void plstream::gesc( char *p_esc )
02605 {
02606 set_stream();
02607
02608 ::plgesc( p_esc );
02609 }
02610
02611
02612
02613 void plstream::cmd( PLINT op, void *ptr )
02614 {
02615 set_stream();
02616
02617 ::pl_cmd( op, ptr );
02618 }
02619
02620
02621
02622 int plstream::FindName( char *p )
02623 {
02624 set_stream();
02625
02626 return plFindName( p );
02627 }
02628
02629
02630
02631 char *plstream::FindCommand( char *fn )
02632 {
02633 set_stream();
02634
02635 return plFindCommand( fn );
02636 }
02637
02638
02639
02640
02641 void plstream::GetName( char *dir, char *subdir, char *filename,
02642 char **filespec )
02643 {
02644 set_stream();
02645
02646 plGetName( dir, subdir, filename, filespec );
02647 }
02648
02649
02650
02651 PLINT plstream::GetInt( char *s )
02652 {
02653 set_stream();
02654
02655 return plGetInt( s );
02656 }
02657
02658
02659
02660 PLFLT plstream::GetFlt( char *s )
02661 {
02662 set_stream();
02663
02664 return plGetFlt( s );
02665 }
02666
02667
02668
02669
02670
02671 void plstream::Alloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny )
02672 {
02673 set_stream();
02674
02675 ::plAlloc2dGrid( f, nx, ny );
02676 }
02677
02678
02679
02680 void plstream::Free2dGrid( PLFLT **f, PLINT nx, PLINT ny )
02681 {
02682 set_stream();
02683
02684 ::plFree2dGrid( f, nx, ny );
02685 }
02686
02687
02688 void plstream::MinMax2dGrid( const PLFLT * const *f, PLINT nx, PLINT ny,
02689 PLFLT *fmax, PLFLT *fmin )
02690 {
02691 set_stream();
02692
02693 ::plMinMax2dGrid( (const PLFLT **) f, nx, ny, fmax, fmin );
02694 }
02695
02696
02697
02698 void plstream::hlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g,
02699 PLFLT *p_b )
02700 {
02701 set_stream();
02702
02703 ::c_plhlsrgb( h, l, s, p_r, p_g, p_b );
02704 }
02705
02706 void plstream::rgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l,
02707 PLFLT *p_s )
02708 {
02709 set_stream();
02710
02711 ::c_plrgbhls( r, g, b, p_h, p_l, p_s );
02712 }
02713
02714
02715
02716 int plstream::GetCursor( PLGraphicsIn *gin )
02717 {
02718 set_stream();
02719
02720 return plGetCursor( gin );
02721 }
02722
02723
02724
02725