GeezerVisonThe World Wide Web, restored to 800 pixels of glory. |
| Home|About|Gaming cabinet|Archives|How it works|Starter sites |
GeezerVison is showing github.com — PLplot/include/plplotP.h at master · PLplot/PLplot Expand file tree/ Copy pathplplotP.hMore file actions 1312 lines (958 loc) · 34.5 KB / Copy pathplplotP.hFile metadata and controls1312 lines (958 loc) · 34.5 KB 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 // Internal (private) macros and prototypes for the PLplot package. This // header file must be included before all others, including system header // files. This file is typically needed when including driver specific // header files (e.g. pltkd.h). // // Copyright (C) 1993, 1994, 1995 by // Maurice J. LeBrun, Geoff Furnish, Tony Richardson. // // Copyright (C) 2004 Rafael Laboissiere // Copyright (C) 2004 Joao Cardoso // Copyright (C) 2004 Andrew Roach // Copyright (C) 2006 Andrew Ross // Copyright (C) 2006 Hazen Babcock // Copyright (C) 2001-2015 Alan W. Irwin // // // This file is part of PLplot. // // PLplot is free software; you can redistribute it and/or modify // it under the terms of the GNU Library General Public License as published // by the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // PLplot is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Library General Public License for more details. // // You should have received a copy of the GNU Library General Public License // along with PLplot; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // // // #ifndef __PLPLOTP_H__ #define __PLPLOTP_H__ //-------------------------------------------------------------------------- // Select environment. Must be done before anything else. // // Basically we want the widest range of system services that are available. // Fortunately on many systems, that is the default. To get "everything", // one of the following must be defined, as appropriate: // // _GNU_SOURCE on Linux (default) // _OSF_SOURCE on OSF1 (default) // _HPUX_SOURCE on HP (not default) // _ALL_SOURCE on AIX (no idea) // // To see where these are set, do the following: // // cd /usr/include; grep SOURCE *.h | fgrep 'define ' // // and the file containing lots of these is the one you want (features.h on // Linux, standards.h on OSF1, etc). Follow the logic to see what needs to be // defined to get "everything", i.e. POSIX.*, XOPEN, etc. // // Note that for specific functionality, we test using autoconf. Still it's // best to stick to ANSI C, POSIX.1, and POSIX.2, in that order, for maximum // portability. //-------------------------------------------------------------------------- // HPUX - if this is no longer needed, please remove it #ifdef _HPUX #define _HPUX_SOURCE #endif // A/IX - if this is no longer needed, please remove it #ifdef _AIX #define _ALL_SOURCE #endif // Add others here as needed. //-------------------------------------------------------------------------- // Configuration settings // // Some of the macros set during configuration are described here. // // If HAVE_TERMIOS_H is set, we employ POSIX.1 tty terminal I/O. // // If STDC_HEADERS is defined, the system's libc is ANSI-compliant. // ANSI libc calls are used for: (a) setting up handlers to be called // before program exit (via the "atexit" call), and (b) for seek // operations. Again, the code is usable without these. An ANSI libc // should be available, given the requirement of an ANSI compiler. Some // reasons why not: (a) the vendor didn't supply a complete ANSI // environment, or (b) the ANSI libc calls are buggy, or (c) you ported // gcc to your system but not glibc (for whatever reason). Note: without // an ANSI C lib, if you ^C out of a program using one of the PLplot tek // drivers, your terminal may be left in a strange state. //-------------------------------------------------------------------------- #include "plConfig.h" #ifdef caddr_t #undef caddr_t #ifndef __USE_BSD typedef char * caddr_t; #endif #endif // System headers #include <ctype.h> #include <math.h> #include <string.h> #include <limits.h> #include <float.h> #ifdef PL_HAVE_UNISTD_H #include <unistd.h> #endif #include <locale.h> // (AM) Define M_PI if the platform does not include it // (MSVC for instance) #if !defined ( M_PI ) #define M_PI 3.14159265358979323846 #endif // // Macros for file positioning. I tried switching to f[sg]etpos() because I // like the semantics better, but ran into the problem that fpos_t is not // always a base type (it may be a struct). This is a problem because the // metafile driver needs to write relative offsets into the file itself. So // instead we use f{seek,tell} at a low level but keep the f[sg]etpos // semantics using these macros. // #ifdef STDC_FPOS_T #undef STDC_FPOS_T #endif #ifdef STDC_FPOS_T #define FPOS_T fpos_t #define pl_fsetpos( a, b ) fsetpos( a, b ) #define pl_fgetpos( a, b ) fgetpos( a, b ) #else #define FPOS_T long #define pl_fsetpos( a, b ) fseek( a, *b, 0 ) #define pl_fgetpos( a, b ) ( -1L == ( *b = ftell( a ) ) ) #endif #include "pldll.h" // Include all externally-visible definitions and prototypes // plplot.h also includes some handy system header files #include "plplot.h" // plstream definition #include "plstrm.h" // If not including this file from inside of plcore.h, declare plsc #ifndef __PLCORE_H__ #ifdef __cplusplus extern "C" { #endif // extern PLStream PLDLLIMPORT *plsc; extern PLDLLIMPEXP_DATA( PLStream * ) plsc; #ifdef __cplusplus } #endif #include "pldebug.h" #endif //-------------------------------------------------------------------------- // Utility macros //-------------------------------------------------------------------------- #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif // Used to help ensure everything malloc'ed gets freed #define free_mem( a ) \ if ( a != NULL ) { free( (void *) a ); a = NULL; } // Allows multi-argument setup calls to not affect selected arguments #define plsetvar( a, b ) \ if ( b != PL_NOTSET ) a = b; // Lots of cool math macros #ifndef MAX #define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) ) #endif #ifndef MIN #define MIN( a, b ) ( ( ( a ) < ( b ) ) ? ( a ) : ( b ) ) #endif #ifndef ABS #define ABS( a ) ( ( a ) < 0 ? -( a ) : ( a ) ) #endif #ifndef ROUND #define ROUND( a ) (PLINT) ( ( a ) < 0. ? ( ( a ) - .5 ) : ( ( a ) + .5 ) ) #endif #ifndef BETW #define BETW( ix, ia, ib ) ( ( ( ix ) <= ( ia ) && ( ix ) >= ( ib ) ) || ( ( ix ) >= ( ia ) && ( ix ) <= ( ib ) ) ) #endif #ifndef SSQR #define SSQR( a, b ) sqrt( ( a ) * ( a ) + ( b ) * ( b ) ) #endif #ifndef SIGN #define SIGN( a ) ( ( a ) < 0 ? -1 : 1 ) #endif #ifndef TRANSFORM #define TRANSFORM( x, y, xnew, ynew ) if ( plsc->coordinate_transform ) { plsc->coordinate_transform( ( x ), ( y ), ( xnew ), ( ynew ), plsc->coordinate_transform_data ); } else { *xnew = x; *ynew = y; } #endif // A coordinate value that should never occur #define PL_UNDEFINED -9999999 // Declarations for save string functions #ifdef PL_HAVE_SNPRINTF // In case only _snprintf is declared (as for Visual C++ and // Borland compiler toolset) we redefine the function names #ifdef _PL_HAVE_SNPRINTF #define snprintf _snprintf #define snscanf _snscanf #endif // _PL_HAVE_SNPRINTF #else // !PL_HAVE_SNPRINTF // declare dummy functions which just call the unsafe // functions ignoring the size of the string int plsnprintf( char *buffer, int n, PLCHAR_VECTOR format, ... ); int plsnscanf( PLCHAR_VECTOR buffer, int n, PLCHAR_VECTOR format, ... ); #define snprintf plsnprintf #define snscanf plsnscanf #endif // PL_HAVE_SNPRINTF //-------------------------------------------------------------------------- // Add in missing isnan / isinf functions on some platforms //-------------------------------------------------------------------------- #if defined ( PL__HAVE_ISNAN ) # define isnan _isnan # if defined ( _MSC_VER ) # include <float.h> # endif #endif #if defined ( PL__HAVE_ISINF ) # define isinf _isinf #endif #if defined ( PL_HAVE_FINITE ) # define isfinite finite #endif #if defined ( PL__HAVE_FINITE ) # define isfinite _finite #endif // Note these replacements follow the old BSD convention and not // C99. In particular isinf does not distinguish +/- inf. #if !defined ( PL_HAVE_ISNAN ) # define isnan( x ) ( ( x ) != ( x ) ) #endif #if !defined ( PL_HAVE_ISINF ) # define isinf( x ) ( !isnan( x ) && isnan( x - x ) ) #endif #if !defined ( PL_HAVE_ISFINITE ) # define isfinite( x ) ( !isnan( x - x ) ) #endif // Check if C99 HUGE_VAL macro is available - if not then // define a replacement #ifndef HUGE_VAL #define HUGE_VAL ( 1.0 / 0.0 ) #endif //-------------------------------------------------------------------------- // PLPLOT control macros //-------------------------------------------------------------------------- // Some constants #define PL_MAXPOLY 256 // Max segments in polyline or polygon #define PL_NSTREAMS 100 // Max number of concurrent streams. #define PL_RGB_COLOR -1 // A hack #define TEXT_MODE 0 #define GRAPHICS_MODE 1 #ifndef PI #define PI 3.1415926535897932384 #endif // These define the virtual coordinate system used by the metafile driver. // Others are free to use it, or some variation, or define their own. // Note desktop monitors of reasonable quality typically have 0.25 mm spacing // between dots which corresponds to 4.0 dots per mm. The parameters here // roughly correspond to a 14" monitor at 1024x768 resolution, which should // work fine at other sizes/resolutions. The number of virtual dots per mm is // scaled by a factor of 32, with pixels scaled accordingly. The customary // x/y ratio of 4:3 is used. // #define PIXELS_X 32768 // Number of virtual pixels in x #define PIXELS_Y 24576 // Number of virtual pixels in x #define DPMM 4. // dots per mm #define VDPMM ( DPMM * 32 ) // virtual dots per mm #define LPAGE_X ( PIXELS_X / VDPMM ) // virtual page length in x in mm (256) #define LPAGE_Y ( PIXELS_Y / VDPMM ) // virtual page length in y in mm (192) // Constants that help to define ideal plspage arguments for devices #define PLPLOT_MM_PER_INCH 25.4 #define PLPLOT_POINTS_PER_INCH 72. #define PLPLOT_WIDTH_A4_MM 297. #define PLPLOT_HEIGHT_A4_MM 210. #define PLPLOT_WIDTH_A5_MM 210. #define PLPLOT_HEIGHT_A5_MM 148. // Devices with pixel units for sizes. // Adopt this default value as reasonable approximation for typical // LCD monitors, but note that the user can replace this default by // setting plsc->[xy]dpi values (e.g., by using the -dpi command-line // option or by calling plspage with non-zero first two arguments). #define PLPLOT_DEFAULT_PIXELS_PER_INCH 90. // These default pixel dimensions correspond to A5 size if actual // pixels per inch is PLPLOT_DEFAULT_PIXELS_PER_INCH #define PLPLOT_DEFAULT_WIDTH_PIXELS ( (int) ( PLPLOT_WIDTH_A5_MM * PLPLOT_DEFAULT_PIXELS_PER_INCH / PLPLOT_MM_PER_INCH ) ) #define PLPLOT_DEFAULT_HEIGHT_PIXELS ( (int) ( PLPLOT_HEIGHT_A5_MM * PLPLOT_DEFAULT_PIXELS_PER_INCH / PLPLOT_MM_PER_INCH ) ) // Devices with real world units for sizes. // N.B. these devices normally use fixed values of units per inch, // i.e., they ignore any attempt by users to set plsc->[xy]dpi values // (e.g., by using the -dpi command-line option or by calling plspage // with non-zero first two arguments). // 1. Devices with mm units for sizes. // These default mm dimensions correspond to A4 size. #define PLPLOT_DEFAULT_WIDTH_MM ( (int) ( PLPLOT_WIDTH_A4_MM ) #define PLPLOT_DEFAULT_HEIGHT_MM ( (int) ( PLPLOT_HEIGHT_A4_MM ) // 2. Devices with points (= 1/72 inch) units for sizes. // These default points dimensions correspond to A4 size. #define PLPLOT_DEFAULT_WIDTH_POINTS ( (int) ( PLPLOT_WIDTH_A4_MM * PLPLOT_POINTS_PER_INCH / PLPLOT_MM_PER_INCH ) ) #define PLPLOT_DEFAULT_HEIGHT_POINTS ( (int) ( PLPLOT_HEIGHT_A4_MM * PLPLOT_POINTS_PER_INCH / PLPLOT_MM_PER_INCH ) ) // This defines the first argument of the plRotPhy invocation that is made // in a number of device drivers (e.g., found in ps.c // and pstex.c) to rotate them "permanently" from portrait mode to non- // portrait mode. ORIENTATION of 1 corresponds to seascape mode (90 deg // clockwise rotation from portrait). This is the traditional value // effectively used in all older versions of PLplot. ORIENTATION of 3 // corresponds to landscape mode (90 deg *counter*-clockwise rotation from // portrait) which is the new default non-portrait orientation. #define ORIENTATION 3 // Switches for state function call. #define PLSTATE_WIDTH 1 // pen width #define PLSTATE_COLOR0 2 // change to color in cmap 0 #define PLSTATE_COLOR1 3 // change to color in cmap 1 #define PLSTATE_FILL 4 // set area fill to a standard pattern #define PLSTATE_CMAP0 5 // change to cmap 0 #define PLSTATE_CMAP1 6 // change to cmap 1 #define PLSTATE_CHR 7 // change character height #define PLSTATE_SYM 8 // change symbol size #define PLSTATE_EOFILL 9 // change to even odd fill rule // Enum for flagging the render status of PLplot enum { AT_BOP, DRAWING, AT_EOP }; // Bit switches used in the driver interface #define PLDI_MAP 0x01 #define PLDI_ORI 0x02 #define PLDI_PLT 0x04 #define PLDI_DEV 0x08 // Default size for family files, in KB. #ifndef PL_FILESIZE_KB #define PL_FILESIZE_KB 1000 #endif // Font file names. #define PLPLOT5_FONTS #ifdef PLPLOT5_FONTS #define PL_XFONT "plxtnd5.fnt" #define PL_SFONT "plstnd5.fnt" #else #define PL_XFONT "plxtnd4.fnt" #define PL_SFONT "plstnd4.fnt" #endif //-------------------------------------------------------------------------- // The following environment variables are defined: // // PLPLOT_BIN # where to find executables // PLPLOT_LIB # where to find library files (fonts, maps, etc) // PLPLOT_TCL # where to find tcl scripts // // PLPLOT_HOME # basename of plplot hierarchy // // search order: // 1) the most specific possible locators, one of // $(PLPLOT_BIN) // $(PLPLOT_LIB) // $(PLPLOT_TCL) // as appropriate // // 2) the current directory // // 3) one of $(PLPLOT_HOME)/bin // $(PLPLOT_HOME)/lib // $(PLPLOT_HOME)/tcl // as appropriate // // 4) as appropriate, the compile-time (Makefile) // BIN_DIR, LIB_DIR, TCL_DIR // // 8 Jun 1994 mj olesen ([email protected]) // // Other notes: // // In addition to the directories above, the following are also used: // // Lib file search path: PLLIBDEV (see plctrl.c). This is checked last, // and is a system-dependent hardwired location. // // Tcl search path: $HOME/tcl is searched before the install location, // TCL_DIR. //-------------------------------------------------------------------------- #define PLPLOT_BIN_ENV "PLPLOT_BIN" #define PLPLOT_LIB_ENV "PLPLOT_LIB" #define PLPLOT_TCL_ENV "PLPLOT_TCL" #define PLPLOT_HOME_ENV "PLPLOT_HOME" // Maximum size for path strings in the plplot code #define PLPLOT_MAX_PATH 1024 // // Some stuff that is included (and compiled into) plsym.h // Other modules might want this, so we will "extern" it // // #ifndef __PLSYM_H__ typedef struct { unsigned int Hershey; PLUNICODE Unicode; char Font; } Hershey_to_Unicode_table; extern int number_of_entries_in_hershey_to_unicode_table; extern Hershey_to_Unicode_table hershey_to_unicode_lookup_table[]; #endif // Greek character translation array (defined in plcore.c) extern const char plP_greek_mnemonic[]; //-------------------------------------------------------------------------- // Function Prototypes // // These typically should not be called directly by the user. //-------------------------------------------------------------------------- #ifdef __cplusplus extern "C" { #endif // Number of elements in the affine vector representation of the affine // transformation matrix. #define NAFFINE 6 // Returns affine identity matrix PLDLLIMPEXP void plP_affine_identity( PLFLT *affine_vector ); // Translate new coordinate system axes relative to the old. PLDLLIMPEXP void plP_affine_translate( PLFLT *affine_vector, PLFLT xtranslate, PLFLT ytranslate ); // Scale new coordinate system axes relative to the old. PLDLLIMPEXP void plP_affine_scale( PLFLT *affine_vector, PLFLT xscale, PLFLT yscale ); // Rotate new coordinate system axes relative to the old. // angle is in degrees. PLDLLIMPEXP void plP_affine_rotate( PLFLT *affine_vector, PLFLT angle ); // Skew new X coordinate axis relative to the old. // angle is in degrees. PLDLLIMPEXP void plP_affine_xskew( PLFLT *affine_vector, PLFLT angle ); // Skew new Y coordinate axis relative to the old. // angle is in degrees. PLDLLIMPEXP void plP_affine_yskew( PLFLT *affine_vector, PLFLT angle ); // Multiply two affine transformation matrices to form a third. // // A = B * C // // PLDLLIMPEXP void plP_affine_multiply( PLFLT *affine_vectorA, PLFLT_VECTOR affine_vectorB, PLFLT_VECTOR affine_vectorC ); // Determines interval between numeric labels void pldtik( PLFLT vmin, PLFLT vmax, PLFLT *tick, PLINT *nsubt, PLBOOL ld ); // Writes numeric labels on side(s) of box in custom locations void label_box_custom( PLCHAR_VECTOR xopt, PLINT n_xticks, PLFLT_VECTOR xticks, PLCHAR_VECTOR yopt, PLINT n_yticks, PLFLT_VECTOR yticks ); // Determine factor to convert date / time in seconds to more natural // units void pldtfac( PLFLT vmin, PLFLT vmax, PLFLT *factor, PLFLT *tstart ); // Determines precision of box labels void pldprec( PLFLT vmin, PLFLT vmax, PLFLT tick, PLINT lf, PLINT *mode, PLINT *prec, PLINT digmax, PLINT *scale ); // Draws a polyline within the clip limits. void plP_pllclp( PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void ( *draw )( short *, short *, PLINT ) ); // Fills a polygon within the clip limits. void plP_plfclp( PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void ( *draw )( short *, short *, PLINT ) ); // Clip a polygon to the 3d bounding plane int plP_clip_poly( int Ni, PLFLT *Vi[3], int axis, PLFLT dir, PLFLT offset ); // Get clipped endpoints int plP_clipline( PLINT *p_x1, PLINT *p_y1, PLINT *p_x2, PLINT *p_y2, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax ); // Stores hex digit value into FCI (font characterization integer). void plP_hex2fci( unsigned char hexdigit, unsigned char hexpower, PLUNICODE *pfci ); // Retrieves hex digit value from FCI (font characterization integer). PLDLLIMPEXP void plP_fci2hex( PLUNICODE fci, unsigned char *phexdigit, unsigned char hexpower ); // Pattern fills in software the polygon bounded by the input points. PLDLLIMPEXP void plfill_soft( short *x, short *y, PLINT npts ); // In case of an abort this routine is called. It just prints out an // error message and tries to clean up as much as possible. PLDLLIMPEXP void plexit( PLCHAR_VECTOR errormsg ); // Just a front-end to exit(). void pl_exit( void ); // A handy way to issue warnings, if need be. PLDLLIMPEXP void plwarn( PLCHAR_VECTOR errormsg ); // Same as plwarn(), but appends ", aborting plot" to the error message PLDLLIMPEXP void plabort( PLCHAR_VECTOR errormsg ); // Loads either the standard or extended font. void plfntld( PLINT fnt ); // Release memory for fonts. void plfontrel( void ); // A replacement for strdup(), which isn't portable. PLDLLIMPEXP char * plstrdup( PLCHAR_VECTOR src ); // Bin up cmap 1 space and assign colors to make inverse mapping easy. PLDLLIMPEXP void plcmap1_calc( void ); // Draws a slanting tick at position (mx,my) (measured in mm) of // vector length (dx,dy). void plstik( PLFLT mx, PLFLT my, PLFLT dx, PLFLT dy ); // Prints out a "string" at reference position with physical coordinates // (refx,refy). void plstr( PLINT base, PLFLT *xform, PLINT refx, PLINT refy, PLCHAR_VECTOR string ); // Draws a tick parallel to x. void plxtik( PLINT x, PLINT y, PLINT below, PLINT above ); // Draws a tick parallel to y. void plytik( PLINT x, PLINT y, PLINT left, PLINT right ); // Driver interface filter -- // passes all coordinates through a variety of filters. PLDLLIMPEXP void difilt( PLINT *, PLINT *, PLINT, PLINT *, PLINT *, PLINT *, PLINT * ); // Transforms the clipping region coordinates as necessary // based on the current plot orientation, etc. PLDLLIMPEXP void difilt_clip( PLINT *, PLINT * ); // Calculate scale of font size and scale of magnitude of vertical // offset associated with superscripts and subscripts. PLDLLIMPEXP void plP_script_scale( PLBOOL ifupper, PLINT *level, PLFLT *old_scale, PLFLT *scale, PLFLT *old_offset, PLFLT *offset ); // Driver draws text void plP_text( PLINT base, PLFLT just, PLFLT *xform, PLINT x, PLINT y, PLINT refx, PLINT refy, PLCHAR_VECTOR string ); // Save LC_NUMERIC locale string, then set "C" locale to protect // parts of PLplot which absolutely demand the LC_NUMERIC "C" locale. PLDLLIMPEXP char * plsave_set_locale( void ); // Restore LC_NUMERIC locale that was determined by plsave_set_locale. PLDLLIMPEXP void plrestore_locale( char * save_lc_numeric_locale ); // Writes the Hershey symbol "ch" centred at the physical coordinate (x,y). void plhrsh( PLINT ch, PLINT x, PLINT y ); // where should structure definitions that must be seen by drivers and core source files, be? // structure to be used by plcore.c and anydriver.c, related to plP_text() typedef struct { // Indicates the type of text stored in the structure. This flag // is used by the plot metafiles to correctly store and then render // the contents. enum { PL_STRING_TEXT, PL_STRING_SYMBOL } text_type; // Positioning settings PLINT base; // ref point at base(1) or center(0) of text. Currently plplot only use 0 PLFLT just; // continuos justification, 0 left, 0.5 center, 1 right PLFLT *xform; // transformation (rotation) matrix // raw reference point--after any transformation PLINT x; PLINT y; // processed ref. point--after justification, displacement, etc, processing PLINT refx; PLINT refy; // font face OPTIONALLY used for rendering hershey codes char font_face; // The following 3 fields are used by the alternative text handling pathway. // The alternative text handling pathway allows the driver to process // each character individually for unicode font handling // See drivers/cairo.h for details about how this works. PLUNICODE n_fci; // font storage PLUNICODE n_char; // character storage PLINT n_ctrl_char; // control character // Used by plsym to store a unicode character for use by plfreetype PLUNICODE unicode_char; // an int to hold either a Hershey, ASC-II, or Unicode value for plsym calls // Used to store a processed unicode string. Used by plsym and // text rendering by the driver PLUNICODE *unicode_array; // a pointer to an array of ints holding either a Hershey, ASC-II, or Unicode value for cached plsym unsigned short unicode_array_len; // Non-unicode strings and unprocessed string in the unicode case const char *string; // text to draw PLINT symbol; // plot symbol to draw }EscText; // // structure that contains driver specific information, to be used by // plargs.c and anydriver.c, related to plParseDrvOpts() and plHelpDrvOpts() // typedef struct { PLCHAR_VECTOR opt; // a string with the name of the option PLINT type; // the type of the variable to be set, see bellow the available types void *var_ptr; // a pointer to the variable to be set PLCHAR_VECTOR hlp_msg; // help message of the option } DrvOpt; // the available variable types, DrvOpt.type, for driver specific options enum { DRV_INT, DRV_FLT, DRV_STR }; // parse driver specific options, as in -drvopt <option[=value]>* PLDLLIMPEXP int plParseDrvOpts( DrvOpt * ); // give help on driver specific options void plHelpDrvOpts( DrvOpt * ); // // structures to store contour lines // #define LINE_ITEMS 20 typedef struct cont_line { PLFLT *x; PLFLT *y; PLINT npts; struct cont_line *next; } CONT_LINE; typedef struct cont_level { // INDENT-OFF (stop infinite recursion) PLFLT level; // contour level struct cont_line *line; // contour line struct struct cont_level *next; // contour level struct // INDENT-ON } CONT_LEVEL; void cont_store( PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ), PLPointer pltr_data, CONT_LEVEL **contour ); void cont_clean_store( CONT_LEVEL *ct ); // Get the viewport boundaries in world coordinates, expanded slightly void plP_xgvpw( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax ); // Get x-y domain in world coordinates for 3d plots void plP_gdom( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax ); // Get vertical (z) scale parameters for 3-d plot void plP_grange( PLFLT *p_zscl, PLFLT *p_zmin, PLFLT *p_zmax ); // Get parameters used in 3d plots void plP_gw3wc( PLFLT *p_dxx, PLFLT *p_dxy, PLFLT *p_dyx, PLFLT *p_dyy, PLFLT *p_dyz ); // Get clip boundaries in physical coordinates void plP_gclp( PLINT *p_ixmin, PLINT *p_ixmax, PLINT *p_iymin, PLINT *p_iymax ); // Set clip boundaries in physical coordinates void plP_sclp( PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax ); // Get physical device limits in physical coordinates PLDLLIMPEXP void plP_gphy( PLINT *p_ixmin, PLINT *p_ixmax, PLINT *p_iymin, PLINT *p_iymax ); // Get number of subpages on physical device and current subpage PLDLLIMPEXP void plP_gsub( PLINT *p_nx, PLINT *p_ny, PLINT *p_cs ); // Set number of subpages on physical device and current subpage PLDLLIMPEXP void plP_ssub( PLINT nx, PLINT ny, PLINT cs ); // Set up plot parameters according to the number of subpages. void plP_subpInit( void ); // Get number of pixels to a millimeter PLDLLIMPEXP void plP_gpixmm( PLFLT *p_x, PLFLT *p_y ); // All the drivers call this to set physical pixels/mm. PLDLLIMPEXP void plP_setpxl( PLFLT xpmm0, PLFLT ypmm0 ); // Get background parameters (including line width) for 3d plot. void plP_gzback( PLINT **zbf, PLINT **zbc, PLFLT **zbt, PLFLT **zbw ); // Move to physical coordinates (x,y). void plP_movphy( PLINT x, PLINT y ); // Draw to physical coordinates (x,y). void plP_draphy( PLINT x, PLINT y ); // Move to world coordinates (x,y). void plP_movwor( PLFLT x, PLFLT y ); // Draw to world coordinates (x,y). void plP_drawor( PLFLT x, PLFLT y ); // Draw polyline in physical coordinates. void plP_draphy_poly( PLINT *x, PLINT *y, PLINT n ); // Draw polyline in world coordinates. void plP_drawor_poly( PLFLT_VECTOR x, PLFLT_VECTOR y, PLINT n ); // Sets up physical limits of plotting device. PLDLLIMPEXP void plP_setphy( PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax ); // Set up the subpage boundaries according to the current subpage selected PLDLLIMPEXP void plP_setsub( void ); // Get the floating point precision (in number of places) in numeric labels. void plP_gprec( PLINT *p_setp, PLINT *p_prec ); // Get the date / time format for numeric labels const char * plP_gtimefmt( void ); // Computes the length of a string in mm, including escape sequences. PLFLT plstrl( PLCHAR_VECTOR string ); // Similar to strpos, but searches for occurence of string str2. PLINT plP_stindex( PLCHAR_VECTOR str1, PLCHAR_VECTOR str2 ); // Searches string str for first occurence of character chr. PLDLLIMPEXP PLINT plP_strpos( PLCHAR_VECTOR str, int chr ); // Searches string str for character chr (case insensitive). PLBOOL plP_stsearch( PLCHAR_VECTOR str, int chr ); // Conversion functions // device coords to physical coords (x) PLINT plP_dcpcx( PLFLT x ); // device coords to physical coords (y) PLINT plP_dcpcy( PLFLT y ); // millimeters from bottom left-hand corner to physical coords (x) PLINT plP_mmpcx( PLFLT x ); // millimeters from bottom left-hand corner to physical coords (y) PLINT plP_mmpcy( PLFLT y ); // world coords to physical coords (x) PLINT plP_wcpcx( PLFLT x ); // world coords to physical coords (y) PLINT plP_wcpcy( PLFLT y ); // physical coords to device coords (x) PLFLT plP_pcdcx( PLINT x ); // physical coords to device coords (y) PLFLT plP_pcdcy( PLINT y ); // millimeters from bottom left corner to device coords (x) PLFLT plP_mmdcx( PLFLT x ); // millimeters from bottom left corner to device coords (y) PLFLT plP_mmdcy( PLFLT y ); // world coords into device coords (x) PLFLT plP_wcdcx( PLFLT x ); // world coords into device coords (y) PLFLT plP_wcdcy( PLFLT y ); |
| You are visitor 01402520 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |