Page

Page(Tcl_Interp *, PlFrame *, int, const char **): plframe.c Page(Tcl_Interp *interp, register PlFrame *plFramePtr, int argc, const char **argv): plframe.c Page(Tcl_Interp *, PlPlotter *, int, CONST char **): plplotter.c Page(Tcl_Interp *interp, register PlPlotter *plPlotterPtr, int argc, CONST char **argv): plplotter.c

ParseOptplargs.c

parseoptsplstream

patplstream

pathplstream

pdf_bopen

pdf_bopen(U_CHAR *buffer, size_t bufmax): pdfutils.c pdf_bopen(U_CHAR *buffer, size_t bufmax): pdfutils.c

pdf_close

pdf_close(PDFstrm *pdfs): pdfutils.c pdf_close(PDFstrm *pdfs): pdfutils.c

pdf_finit

pdf_finit(FILE *file): pdfutils.c pdf_finit(FILE *file): pdfutils.c

pdf_fopen

pdf_fopen(PLCHAR_VECTOR filename, PLCHAR_VECTOR mode): pdfutils.c pdf_fopen(const char *fileName, const char *mode): pdfutils.c

pdf_getc

pdf_getc(PDFstrm *pdfs): pdfutils.c pdf_getc(PDFstrm *pdfs): pdfutils.c

pdf_putc

pdf_putc(int c, PDFstrm *pdfs): pdfutils.c pdf_putc(int c, PDFstrm *pdfs): pdfutils.c

pdf_rd_1byte

pdf_rd_1byte(PDFstrm *pdfs, U_CHAR *ps): pdfutils.c pdf_rd_1byte(PDFstrm *pdfs, U_CHAR *ps): pdfutils.c

pdf_rd_2bytes

pdf_rd_2bytes(PDFstrm *pdfs, U_SHORT *ps): pdfutils.c pdf_rd_2bytes(PDFstrm *pdfs, U_SHORT *ps): pdfutils.c

pdf_rd_2nbytes

pdf_rd_2nbytes(PDFstrm *pdfs, U_SHORT *s, PLINT n): pdfutils.c pdf_rd_2nbytes(PDFstrm *pdfs, U_SHORT *s, PLINT n): pdfutils.c

pdf_rd_4bytes

pdf_rd_4bytes(PDFstrm *pdfs, U_LONG *ps): pdfutils.c pdf_rd_4bytes(PDFstrm *pdfs, U_LONG *ps): pdfutils.c

pdf_rd_header

pdf_rd_header(PDFstrm *pdfs, char *header): pdfutils.c pdf_rd_header(PDFstrm *pdfs, char *header): pdfutils.c

pdf_rd_ieeef

pdf_rd_ieeef(PDFstrm *pdfs, float *pf): pdfutils.c pdf_rd_ieeef(PDFstrm *pdfs, float *pf): pdfutils.c

pdf_rd_string

pdf_rd_string(PDFstrm *pdfs, char *string, int nmax): pdfutils.c pdf_rd_string(PDFstrm *pdfs, char *string, int nmax): pdfutils.c

pdf_rdx

pdf_rdx(U_CHAR *x, long nitems, PDFstrm *pdfs): pdfutils.c pdf_rdx(U_CHAR *x, long nitems, PDFstrm *pdfs): pdfutils.c

pdf_set

pdf_set(char *option, int value): pdfutils.c pdf_set(char *option, int value): pdfutils.c

pdf_ungetc

pdf_ungetc(int c, PDFstrm *pdfs): pdfutils.c pdf_ungetc(int c, PDFstrm *pdfs): pdfutils.c

pdf_wr_1byte

pdf_wr_1byte(PDFstrm *pdfs, U_CHAR s): pdfutils.c pdf_wr_1byte(PDFstrm *pdfs, U_CHAR s): pdfutils.c

pdf_wr_2bytes

pdf_wr_2bytes(PDFstrm *pdfs, U_SHORT s): pdfutils.c pdf_wr_2bytes(PDFstrm *pdfs, U_SHORT s): pdfutils.c

pdf_wr_2nbytes

pdf_wr_2nbytes(PDFstrm *pdfs, U_SHORT *s, PLINT n): pdfutils.c pdf_wr_2nbytes(PDFstrm *pdfs, U_SHORT *s, PLINT n): pdfutils.c

pdf_wr_4bytes

pdf_wr_4bytes(PDFstrm *pdfs, U_LONG s): pdfutils.c pdf_wr_4bytes(PDFstrm *pdfs, U_LONG s): pdfutils.c

pdf_wr_header

pdf_wr_header(PDFstrm *pdfs, PLCHAR_VECTOR header): pdfutils.c pdf_wr_header(PDFstrm *pdfs, const char *header): pdfutils.c

pdf_wr_ieeef

pdf_wr_ieeef(PDFstrm *pdfs, float f): pdfutils.c pdf_wr_ieeef(PDFstrm *pdfs, float f): pdfutils.c

pdf_wr_string

pdf_wr_string(PDFstrm *pdfs, PLCHAR_VECTOR string): pdfutils.c pdf_wr_string(PDFstrm *pdfs, const char *string): pdfutils.c

pdf_wrxpdfutils.c

pl3cutplot3d.c

pl_cmd

pl_cmd(): plctrl.c plplot::pl_cmd()pl_cmd(): plctrl.c

pl_cpcolor

pl_cpcolor(PLColor *to, PLColor *from): plcore.c pl_cpcolor(PLColor *to, PLColor *from): plcore.c

pl_create_tempfifo

pl_create_tempfifo(const char **p_fifoname, const char **p_dirname): plstdio.c pl_create_tempfifo(const char **p_fifoname, const char **p_dirname): plstdio.c

pl_create_tempfile

pl_create_tempfile(char **fname): plstdio.c pl_create_tempfile(char **fname): plstdio.c

pl_drawcontlabelplcont.c

pl_exitplplotP.h

pl_PacketReceivetcpip.h

pl_PacketSendtcpip.h

pl_setcontlabelformatplplotc

pl_setcontlabelformat_impl

plplot::pl_setcontlabelformat::pl_setcontlabelformat_impl()plplot::pl_setcontlabelformat_impl()

pl_setcontlabelformatCmd

pl_setcontlabelformatCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pl_setcontlabelformatCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pl_setcontlabelparamplplotc

pl_setcontlabelparamCmd

pl_setcontlabelparamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pl_setcontlabelparamCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plabort

plabort(PLCHAR_VECTOR errormsg): plctrl.c plabort(PLCHAR_VECTOR errormsg): plctrl.c

plabvplot3d.c

pladvplplotc

pladv_impl

plplot::pladv::pladv_impl()plplot::pladv_impl()

pladvCmd

pladvCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pladvCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plAlloc2dGrid

plAlloc2dGrid(): plmem.c plplot::plAlloc2dGrid()plAlloc2dGrid(): plplot.h

plAllocDev

plAllocDev(PLStream *pls): plctrl.c plAllocDev(PLStream *pls): plctrl.c

plarcplplotc

plarc_approxplarc.c

plarcCmd

plarcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plarcCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plaxes

plplot::plaxes()plplotc.plaxes()

plaxesCmd

plaxesCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plaxesCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

PlbasicInit

PlbasicInit(Tcl_Interp *interp): tclAPI.c PlbasicInit(Tcl_Interp *interp): tclAPI.c

plbin

plplot::plbin()plplotc.plbin()

plbinCmd

plbinCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plbinCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plbopplplotc

plbop_impl

plplot::plbop::plbop_impl()plplot::plbop_impl()

plbopCmd

plbopCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plbopCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plbox

plplot::plbox()plplotc.plbox()

plbox3

plplot::plbox3()plplotc.plbox3()

plbox3Cmd

plbox3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plbox3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plboxCmd

plboxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plboxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plbtimeplplotc

plbtimeCmd

plbtimeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plbtimeCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plbuf_bop

plbuf_bop(PLStream *pls): plbuf.c plbuf_bop(PLStream *): plbuf.c

plbuf_clip

plbuf_clip(PLStream *pls): plbuf.c plbuf_clip(PLStream *): plbuf.c

plbuf_controlplbuf.c

plbuf_di

plbuf_di(PLStream *pls): plbuf.c plbuf_di(PLStream *): plbuf.c

plbuf_eop

plbuf_eop(PLStream *pls): plbuf.c plbuf_eop(PLStream *): plbuf.c

plbuf_esc

plbuf_esc(PLStream *pls, PLINT op, void *ptr): plbuf.c plbuf_esc(PLStream *, PLINT, void *): plbuf.c

plbuf_fillplbuf.c

plbuf_imageplbuf.c

plbuf_init

plbuf_init(PLStream *pls): plbuf.c plbuf_init(PLStream *): plbuf.c

plbuf_line

plbuf_line(PLStream *pls, short x1a, short y1a, short x2a, short y2a): plbuf.c plbuf_line(PLStream *, short, short, short, short): plbuf.c

plbuf_polyline

plbuf_polyline(PLStream *pls, short *xa, short *ya, PLINT npts): plbuf.c plbuf_polyline(PLStream *, short *, short *, PLINT): plbuf.c

plbuf_restore

plbuf_restore(PLStream *pls, void *state): plbuf.c plbuf_restore(PLStream *, void *): plbuf.c

plbuf_save

plbuf_save(PLStream *pls, void *state): plbuf.c plbuf_save(PLStream *, void *): plbuf.c

plbuf_setsub

plbuf_setsub(PLStream *pls): plbuf.c plbuf_setsub(PLStream *): plbuf.c

plbuf_ssub

plbuf_ssub(PLStream *pls): plbuf.c plbuf_ssub(PLStream *): plbuf.c

plbuf_state

plbuf_state(PLStream *pls, PLINT op): plbuf.c plbuf_state(PLStream *, PLINT): plbuf.c

plbuf_swinplbuf.c

plbuf_switch

plbuf_switch(PLStream *pls, void *state): plbuf.c plbuf_switch(PLStream *, void *): plbuf.c

plbuf_textplbuf.c

plbuf_text_unicodeplbuf.c

plbuf_tidy

plbuf_tidy(PLStream *PL_UNUSED(pls)): plbuf.c plbuf_tidy(PLStream *): drivers.h

plbuf_writeplbuf.c

plcalc_worldplplotc

plcalc_worldCmd

plcalc_worldCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plcalc_worldCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plcharplsym.c

plclearplplotc

plclear_impl

plplot::plclear::plclear_impl()plplot::plclear_impl()

plclearCmd

plclearCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plclearCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plClearOpts

plClearOpts(): plargs.c plplot::plClearOpts()plClearOpts(): plargs.c plplotc.plClearOpts()

plCloseFile

plCloseFile(PLStream *pls): plctrl.c plCloseFile(PLStream *pls): plctrl.c

plcmap0_defplctrl.c

plcmap1_calc

plcmap1_calc(void): plctrl.c plcmap1_calc(void): plctrl.c

plcmap1_defplctrl.c

plcntrplcont.c

plcol0plplotc

plcol0_impl

plplot::plcol0::plcol0_impl()plplot::plcol0_impl()

plcol0Cmd

plcol0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plcol0Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plcol1plplotc

plcol1Cmd

plcol1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plcol1Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plcol_interp

plcol_interp(PLStream *pls, PLColor *newcolor, int i, int ncol): plctrl.c plcol_interp(PLStream *pls, PLColor *newcolor, int i, int ncol): plctrl.c

PLColor_from_TkColorpltkwd.h

PLColor_from_TkColor_Changedpltkwd.h

PLColor_to_TkColorpltkwd.h

plcolorbar

plplot::plcolorbar()plplotc.plcolorbar()

plcolorbarCmd

plcolorbarCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plcolorbarCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plconfigtimeplplotc

plconfigtimeCmd

plconfigtimeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plconfigtimeCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plcont

plplot::plcont(PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel, pltr_func pltr, PLPointer pltr_data=null)plplot::plcont(PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel, ref PLcGrid cgrid)plplot::plcont(PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel, ref PLcGrid2 cgrid2)plplotc.plcont()

plcontCmd

plcontCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plcontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plcpstrmplplotc

plcpstrm_impl

plplot::plcpstrm::plcpstrm_impl()plplot::plcpstrm_impl()

plcpstrmCmd

plcpstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plcpstrmCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plctest

plctest(PLFLT *x, PLFLT level): plshade.c plctest(PLFLT *x, PLFLT PL_UNUSED(level)): plshade.c

plctestezplshade.c

plctimeplplotc

plctimeCmd

plctimeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plctimeCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plcvecplsym.c

plD_bop_aqtaqt.c

plD_bop_cairocairo.c

plD_bop_ps

plD_bop_ps(PLStream *pls): ps.c plD_bop_ps(PLStream *): ps.c

plD_bop_pstexps.h

plD_bop_psttf

plD_bop_psttf(PLStream *pls): psttf.cc plD_bop_psttf(PLStream *): psttf.cc

plD_bop_svgsvg.c

plD_bop_wxwidgets

plD_bop_wxwidgets(PLStream *pls): wxwidgets.cpp plD_bop_wxwidgets(PLStream *): wxwidgets.cpp

plD_dispatch_init_aqt

plD_dispatch_init_aqt(PLDispatchTable *pdt): aqt.c plD_dispatch_init_aqt(PLDispatchTable *pdt): aqt.c

plD_dispatch_init_bmpqtdrivers.h

plD_dispatch_init_cgmdrivers.h

plD_dispatch_init_epscairodrivers.h

plD_dispatch_init_epsqtdrivers.h

plD_dispatch_init_extcairodrivers.h

plD_dispatch_init_extqtdrivers.h

plD_dispatch_init_gifdrivers.h

plD_dispatch_init_jpegdrivers.h

plD_dispatch_init_jpgqtdrivers.h

plD_dispatch_init_memdrivers.h

plD_dispatch_init_memcairodrivers.h

plD_dispatch_init_memqtdrivers.h

plD_dispatch_init_ntkdrivers.h

plD_dispatch_init_nulldrivers.h

plD_dispatch_init_pdfdrivers.h

plD_dispatch_init_pdfcairodrivers.h

plD_dispatch_init_pdfqtdrivers.h

plD_dispatch_init_plmdrivers.h

plD_dispatch_init_pngdrivers.h

plD_dispatch_init_pngcairodrivers.h

plD_dispatch_init_pngqtdrivers.h

plD_dispatch_init_ppmqtdrivers.h

plD_dispatch_init_psdrivers.h

plD_dispatch_init_pscdrivers.h

plD_dispatch_init_pscairodrivers.h

plD_dispatch_init_pstexdrivers.h

plD_dispatch_init_psttfdrivers.h

plD_dispatch_init_psttfcdrivers.h

plD_dispatch_init_qtwidgetdrivers.h

plD_dispatch_init_svg

plD_dispatch_init_svg(PLDispatchTable *pdt): svg.c plD_dispatch_init_svg(PLDispatchTable *pdt): svg.c

plD_dispatch_init_svgcairodrivers.h

plD_dispatch_init_svgqtdrivers.h

plD_dispatch_init_tiffqtdrivers.h

plD_dispatch_init_tkdrivers.h

plD_dispatch_init_tkwindrivers.h

plD_dispatch_init_wincairodrivers.h

plD_dispatch_init_wingccdrivers.h

plD_dispatch_init_wingdidrivers.h

plD_dispatch_init_wxpngdrivers.h

plD_dispatch_init_wxwidgetsdrivers.h

plD_dispatch_init_xcairodrivers.h

plD_dispatch_init_xfigdrivers.h

plD_dispatch_init_xwdrivers.h

plD_eop_aqtaqt.c

plD_eop_cairocairo.c

plD_eop_ps

plD_eop_ps(PLStream *pls): ps.c plD_eop_ps(PLStream *): ps.c

plD_eop_pstexps.h

plD_eop_psttf

plD_eop_psttf(PLStream *pls): psttf.cc plD_eop_psttf(PLStream *): psttf.cc

plD_eop_svgsvg.c

plD_eop_wxwidgets

plD_eop_wxwidgets(PLStream *pls): wxwidgets.cpp plD_eop_wxwidgets(PLStream *): wxwidgets.cpp

plD_esc_aqtaqt.c

plD_esc_cairocairo.c

plD_esc_ps

plD_esc_ps(PLStream *pls, PLINT op, void *ptr): ps.c plD_esc_ps(PLStream *, PLINT, void *): ps.c

plD_esc_pstexps.h

plD_esc_psttf

plD_esc_psttf(PLStream *pls, PLINT op, void *ptr): psttf.cc plD_esc_psttf(PLStream *, PLINT, void *): psttf.cc

plD_esc_svgsvg.c

plD_esc_wxwidgets

plD_esc_wxwidgets(PLStream *pls, PLINT op, void *ptr): wxwidgets.cpp plD_esc_wxwidgets(PLStream *, PLINT, void *): wxwidgets.cpp

plD_init_aqtaqt.c

plD_init_psps.h

plD_init_pscps.h

plD_init_pstexps.h

plD_init_psttfps.h

plD_init_psttfcps.h

plD_init_svgsvg.c

plD_init_wxpngwxwidgets.h

plD_init_wxwidgetswxwidgets.h

plD_line_aqtaqt.c

plD_line_cairocairo.c

plD_line_ps

plD_line_ps(PLStream *pls, short x1a, short y1a, short x2a, short y2a): ps.c plD_line_ps(PLStream *, short, short, short, short): ps.c

plD_line_pstexps.h

plD_line_psttf

plD_line_psttf(PLStream *pls, short x1a, short y1a, short x2a, short y2a): psttf.cc plD_line_psttf(PLStream *, short, short, short, short): psttf.cc

plD_line_svgsvg.c

plD_line_wxwidgets

plD_line_wxwidgets(PLStream *pls, short x1a, short y1a, short x2a, short y2a): wxwidgets.cpp plD_line_wxwidgets(PLStream *, short, short, short, short): wxwidgets.cpp

plD_open_tkwinpltkwd.h

plD_polyline_aqtaqt.c

plD_polyline_cairocairo.c

plD_polyline_ps

plD_polyline_ps(PLStream *pls, short *xa, short *ya, PLINT npts): ps.c plD_polyline_ps(PLStream *, short *, short *, PLINT): ps.c

plD_polyline_pstexps.h

plD_polyline_psttf

plD_polyline_psttf(PLStream *pls, short *xa, short *ya, PLINT npts): psttf.cc plD_polyline_psttf(PLStream *, short *, short *, PLINT): psttf.cc

plD_polyline_svgsvg.c

plD_polyline_wxwidgets

plD_polyline_wxwidgets(PLStream *pls, short *xa, short *ya, PLINT npts): wxwidgets.cpp plD_polyline_wxwidgets(PLStream *, short *, short *, PLINT): wxwidgets.cpp

plD_state_aqtaqt.c

plD_state_cairo

plD_state_cairo(PLStream *, PLINT): cairo.c plD_state_cairo(PLStream *PL_UNUSED(pls), PLINT PL_UNUSED(op)): cairo.c

plD_state_ps

plD_state_ps(PLStream *pls, PLINT op): ps.c plD_state_ps(PLStream *, PLINT): ps.c

plD_state_pstexps.h

plD_state_psttf

plD_state_psttf(PLStream *pls, PLINT op): psttf.cc plD_state_psttf(PLStream *, PLINT): psttf.cc

plD_state_svg

plD_state_svg(PLStream *, PLINT): svg.c plD_state_svg(PLStream *PL_UNUSED(pls), PLINT PL_UNUSED(op)): svg.c

plD_state_wxwidgets

plD_state_wxwidgets(PLStream *pls, PLINT op): wxwidgets.cpp plD_state_wxwidgets(PLStream *, PLINT): wxwidgets.cpp

plD_tidy_aqtaqt.c

plD_tidy_cairocairo.c

plD_tidy_ps

plD_tidy_ps(PLStream *pls): ps.c plD_tidy_ps(PLStream *): ps.c

plD_tidy_pstexps.h

plD_tidy_psttf

plD_tidy_psttf(PLStream *pls): psttf.cc plD_tidy_psttf(PLStream *): psttf.cc

plD_tidy_svgsvg.c

plD_tidy_wxwidgets

plD_tidy_wxwidgets(PLStream *pls): wxwidgets.cpp plD_tidy_wxwidgets(PLStream *): wxwidgets.cpp

plD_wait_wxwidgets

plD_wait_wxwidgets(PLStream *pls): wxwidgets.cpp plD_wait_wxwidgets(PLStream *): wxwidgets.cpp

pldecoplsym.c

PlDevicePlDevice

pldi_ini

pldi_ini(void): plcore.c pldi_ini(void): plcore.h

pldid2pc

pldid2pc(): plcore.c plplot::pldid2pc()pldid2pc(): plplot.h

pldid2pcCmd

pldid2pcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pldid2pcCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pldip2dc

pldip2dc(): plcore.c plplot::pldip2dc()pldip2dc(): plplot.h

pldip2dcCmd

pldip2dcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pldip2dcCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plDispatchSequencerplcore.c

PLDLLIMPEXP_DATA

PLDLLIMPEXP_DATA(PLStream) *plsc: plcore.h PLDLLIMPEXP_DATA(PLStream *) plsc: plplotP.h

PLDLLIMPEXP_DRIVER_DATAqt.cpp

PLDLLIMPEXP_QT_DATA

PLDLLIMPEXP_QT_DATA(int) vectorize=0: plqt.cpp PLDLLIMPEXP_QT_DATA(MasterHandler) handler: plqt.cpp PLDLLIMPEXP_QT_DATA(int) vectorize: qt.h PLDLLIMPEXP_QT_DATA(MasterHandler) handler: qt.h

pldprec

pldprec(PLFLT vmin, PLFLT vmax, PLFLT tick, PLINT lf, PLINT *mode, PLINT *prec, PLINT digmax, PLINT *scale): pldtik.c pldprec(PLFLT vmin, PLFLT vmax, PLFLT tick, PLINT lf, PLINT *mode, PLINT *prec, PLINT digmax, PLINT *scale): pldtik.c

pldrawcnplcont.c

pldtfac

pldtfac(PLFLT vmin, PLFLT vmax, PLFLT *factor, PLFLT *start): pldtik.c pldtfac(PLFLT vmin, PLFLT vmax, PLFLT *factor, PLFLT *tstart): pldtik.c

pldtik

pldtik(PLFLT vmin, PLFLT vmax, PLFLT *tick, PLINT *nsubt, PLBOOL ld): pldtik.c pldtik(PLFLT vmin, PLFLT vmax, PLFLT *tick, PLINT *nsubt, PLBOOL ld): pldtik.c

pldummy_cgmcgm.c

pldummy_ntkntk.c

pldummy_nullnull.c

pldummy_pdfpdf.c

pldummy_plmetaplmeta.c

pldummy_pnggd.c

pldummy_pstexpstex.c

pldummy_tcpiptcpip.c

pldummy_tktk.c

pldummy_tkwintkwin.c

pldummy_wingccwingcc.c

pldummy_wingdiwingdi.c

pldummy_xfigxfig.c

pldummy_xwinxwin.c

plendplplotc

plend1plplotc

plend1_impl

plplot::plend1::plend1_impl()plplot::plend1_impl()

plend1Cmd

plend1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plend1Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plend_impl

plplot::plend::plend_impl()plplot::plend_impl()

plendCmd

plendCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plendCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plenvplplotc

plenv0plplotc

plenv0Cmd

plenv0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plenv0Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plenvCmd

plenvCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plenvCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pleopplplotc

pleop_impl

plplot::pleop::pleop_impl()plplot::pleop_impl()

pleopCmd

pleopCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pleopCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plerrx

plplot::plerrx()plplotc.plerrx()

plerrxCmd

plerrxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plerrxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plerry

plplot::plerry()plplotc.plerry()

plerryCmd

plerryCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plerryCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plerx1pltick.c

plery1pltick.c

plexit

plexit(PLCHAR_VECTOR errormsg): plctrl.c plexit(PLCHAR_VECTOR errormsg): plctrl.c

plExitCmd

plExitCmd(ClientData clientData, Tcl_Interp *interp, int argc, char **argv): pltcl.c plExitCmd(ClientData clientData, Tcl_Interp *interp, int argc, char **argv): plserver.c plExitCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, char **argv): plserver.c

plf2eval

plf2eval(): plcont.c plplot::plf2eval()plf2eval(): plcont.c

plf2eval1

plf2eval1(PLINT ix, PLINT iy, PLPointer plf2eval_data): plcont.c plf2eval1(PLINT ix, PLINT iy, PLPointer plf2eval_data): plcont.c

plf2eval2

plf2eval2(): plcont.c plplot::plf2eval2()plf2eval2(): plcont.c

plf2evalr

plf2evalr(): plcont.c plplot::plf2evalr()plf2evalr(): plcont.c

plf2ops_c

plf2ops_c(): plf2ops.c plf2ops_c(void): plf2ops.c

plf2ops_c_addplf2ops.c

plf2ops_c_divplf2ops.c

plf2ops_c_f2evalplf2ops.c

plf2ops_c_getplf2ops.c

plf2ops_c_isnanplf2ops.c

plf2ops_c_minmaxplf2ops.c

plf2ops_c_mulplf2ops.c

plf2ops_c_setplf2ops.c

plf2ops_c_subplf2ops.c

plf2ops_grid_c

plf2ops_grid_c(): plf2ops.c plf2ops_grid_c(void): plf2ops.c

plf2ops_grid_c_addplf2ops.c

plf2ops_grid_c_divplf2ops.c

plf2ops_grid_c_f2evalplf2ops.c

plf2ops_grid_c_getplf2ops.c

plf2ops_grid_c_isnanplf2ops.c

plf2ops_grid_c_minmaxplf2ops.c

plf2ops_grid_c_mulplf2ops.c

plf2ops_grid_c_setplf2ops.c

plf2ops_grid_c_subplf2ops.c

plf2ops_grid_col_major

plf2ops_grid_col_major(): plf2ops.c plf2ops_grid_col_major(void): plf2ops.c

plf2ops_grid_col_major_addplf2ops.c

plf2ops_grid_col_major_divplf2ops.c

plf2ops_grid_col_major_f2evalplf2ops.c

plf2ops_grid_col_major_getplf2ops.c

plf2ops_grid_col_major_isnanplf2ops.c

plf2ops_grid_col_major_mulplf2ops.c

plf2ops_grid_col_major_setplf2ops.c

plf2ops_grid_col_major_subplf2ops.c

plf2ops_grid_row_major

plf2ops_grid_row_major(): plf2ops.c plf2ops_grid_row_major(void): plf2ops.c

plf2ops_grid_row_major_addplf2ops.c

plf2ops_grid_row_major_divplf2ops.c

plf2ops_grid_row_major_f2evalplf2ops.c

plf2ops_grid_row_major_getplf2ops.c

plf2ops_grid_row_major_isnanplf2ops.c

plf2ops_grid_row_major_mulplf2ops.c

plf2ops_grid_row_major_setplf2ops.c

plf2ops_grid_row_major_subplf2ops.c

plf2ops_grid_xxx_major_minmaxplf2ops.c

plfamadvplplotc

plfamadv_impl

plplot::plfamadv::plfamadv_impl()plplot::plfamadv_impl()

plfamadvCmd

plfamadvCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plfamadvCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plFamInit

plFamInit(PLStream *pls): plctrl.c plFamInit(PLStream *pls): plctrl.c

plfcont

plfcont(): plcont.c plplot::plfcont()plfcont(): plcont.c

plfgriddata

plfgriddata(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_VECTOR z, PLINT npts, PLFLT_VECTOR xg, PLINT nptsx, PLFLT_VECTOR yg, PLINT nptsy, PLF2OPS zops, PLPointer zgp, PLINT type, PLFLT data): plgridd.c plfgriddata(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_VECTOR z, PLINT npts, PLFLT_VECTOR xg, PLINT nptsx, PLFLT_VECTOR yg, PLINT nptsy, PLF2OPS zops, PLPointer zgp, PLINT type, PLFLT data): plgridd.c

plfill

plplot::plfill()plplotc.plfill()

plfill3

plplot::plfill3()plplotc.plfill3()

plfill3Cmd

plfill3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plfill3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plfill_soft

plfill_soft(short *x, short *y, PLINT n): plfill.c plfill_soft(short *x, short *y, PLINT npts): plfill.c

plfillCmd

plfillCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plfillCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plfimage

plfimage(PLF2OPS idataops, PLPointer idatap, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax): plimage.c plfimage(PLF2OPS idataops, PLPointer idatap, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax): plimage.c

plfimagefr

plfimagefr(PLF2OPS idataops, PLPointer idatap, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data): plimage.c plfimagefr(PLF2OPS idataops, PLPointer idatap, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data): plimage.c

plFindCommand

plFindCommand(): plctrl.c plplot::plFindCommand()plFindCommand(): plctrl.c

plFindName

plFindName(): plctrl.c plplot::plFindName()plFindName(): plctrl.c

plfloatlabelplcont.c

plflushplplotc

plflush_impl

plplot::plflush::plflush_impl()plplot::plflush_impl()

plFlushBuffer

plFlushBuffer(PLStream *pls, PLBOOL restart, size_t amount): plbuf.c plFlushBuffer(PLStream *pls, PLBOOL restart, size_t amount): plbuf.c

plflushCmd

plflushCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plflushCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plfmesh

plfmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt): plot3d.c plfmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt): plot3d.c

plfmeshc

plfmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel): plot3d.c plfmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel): plot3d.c

plfntld

plfntld(PLINT fnt): plsym.c plfntld(PLINT fnt): plsym.c

plfontplplotc

plfont_impl

plplot::plfont::plfont_impl()plplot::plfont_impl()

plfontCmd

plfontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plfontCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plfontldplplotc

plfontld_impl

plplot::plfontld::plfontld_impl()plplot::plfontld_impl()

plfontldCmd

plfontldCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plfontldCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plfontrel

plfontrel(void): plsym.c plfontrel(void): plsym.c

plFontToWxFontParameterswxwidgets_dev.cpp

plformplbox.c

plfplot3d

plfplot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLBOOL side): plot3d.c plfplot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLBOOL side): plot3d.c

plfplot3dc

plfplot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel): plot3d.c plfplot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel): plot3d.c

plfplot3dcl

plfplot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT PL_UNUSED(indexxmin), PLINT PL_UNUSED(indexxmax), PLINT_VECTOR PL_UNUSED(indexymin), PLINT_VECTOR PL_UNUSED(indexymax)): plot3d.c plfplot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax): plplot.h

plFrameCmd

plFrameCmd(ClientData, Tcl_Interp *, int, const char **): plframe.c plFrameCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char **argv): plframe.c plFrameCmd(ClientData clientData, Tcl_Interp *interp, int argc, const char **argv): plserver.h

PlFrameConfigureEH

PlFrameConfigureEH(ClientData, XEvent *): plframe.c PlFrameConfigureEH(ClientData clientData, register XEvent *eventPtr): plframe.c

PlFrameEnterEHplframe.c

PlFrameExposeEH

PlFrameExposeEH(ClientData, XEvent *): plframe.c PlFrameExposeEH(ClientData clientData, register XEvent *eventPtr): plframe.c

PlFrameInitplframe.c

PlFrameKeyEHplframe.c

PlFrameLeaveEH

PlFrameLeaveEH(ClientData, register XEvent *): plframe.c PlFrameLeaveEH(ClientData clientData, register XEvent *PL_UNUSED(eventPtr)): plframe.c

PlFrameMotionEHplframe.c

PlFrameWidgetCmdplframe.c

plFree2dGrid

plFree2dGrid(): plmem.c plplot::plFree2dGrid()plFree2dGrid(): plplot.h

plfreetypeplfreetype.c

plfshade

plfshade(): plshade.c plplot::plfshade()plfshade(): plshade.c

plfshade1

plfshade1(PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, 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, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data): plshade.c plfshade1(PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, 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, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data): plshade.c

plfshades

plfshades(PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data): plshade.c plfshades(PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data): plshade.c

plfsurf3d

plfsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel): plot3d.c plfsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel): plot3d.c

plfsurf3dl

plfsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax): plot3d.c plfsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax): plot3d.c

plfvect

plfvect(PLF2EVAL_callback getuv, PLPointer up, PLPointer vp, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data): plvect.c plfvect(PLF2EVAL_callback getuv, PLPointer up, PLPointer vp, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data): plvect.c plfvect(PLFLT(*plf2eval)(PLINT, PLINT, PLPointer), PLPointer f2evalv_data, PLPointer f2evalc_data, PLINT nx, PLINT ny, PLFLT scale, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data): plplotP.h

plg_current_col0plplot_impl.c

plg_current_col1plplot_impl.c

plgchrplplotc

plgchrCmd

plgchrCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgchrCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgchrhtplplot_impl.c

plgcmap1_rangeplplotc

plgcmap1_rangeCmd

plgcmap1_rangeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgcmap1_rangeCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgcol0plplotc

plgcol0_impl

plplot::plgcol0::plgcol0_impl()plplot::plgcol0_impl()

plgcol0aplplotc

plgcol0aCmd

plgcol0aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgcol0aCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgcol0Cmd

plgcol0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgcol0Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgcolbgplplotc

plgcolbg_impl

plplot::plgcolbg::plgcolbg_impl()plplot::plgcolbg_impl()

plgcolbgaplplotc

plgcolbgaCmd

plgcolbgaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgcolbgaCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgcolbgCmd

plgcolbgCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgcolbgCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgcompressionplplotc

plgcompression_impl

plplot::plgcompression::plgcompression_impl()plplot::plgcompression_impl()

plgcompressionCmd

plgcompressionCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgcompressionCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgdev

plplot::plgdev()plplotc.plgdev()

plgdev_impl

plplot::plgdev::plgdev_impl()plplot::plgdev_impl()

plgdevCmd

plgdevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgdevCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgdevlst

plgdevlst(const char **p_menustr, const char **p_devname, int *p_ndev, int type): plcore.c plgdevlst(const char **, const char **, int *, int): plcore.h

plgDevs

plgDevs(): plcore.c plplot::plgDevs()plgDevs(): plcore.c

plgdidevplplotc

plgdidevCmd

plgdidevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgdidevCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgdioriplplotc

plgdioriCmd

plgdioriCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgdioriCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgdipltplplotc

plgdipltCmd

plgdipltCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgdipltCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgdrawmode_impl

plplot::plgdrawmode::plgdrawmode_impl()plplot::plgdrawmode_impl()

plgesc

plgesc(): plcore.c plplot::plgesc()plgesc(): plcore.c

plgesc_stringplbox.c

plgescCmd

plgescCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgescCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plget_arguments_dynamic

plplot::plget_arguments::plget_arguments_dynamic()plplot::plget_arguments_dynamic()

plget_arguments_static

plplot::plget_arguments::plget_arguments_static()plplot::plget_arguments_static()

plget_arguments_static_length

plplot::plget_arguments::plget_arguments_static_length()plplot::plget_arguments_static_length()

plGetAngleToLightplot3d.c

plGetCursor

plGetCursor(): plpage.c plplot::plGetCursor()plGetCursor(): plpage.c plplotc.plGetCursor()

plgetcursor_impl

plplot_graphics::plgetcursor::plgetcursor_impl()plplot_graphics::plgetcursor_impl()

plGetFam

plGetFam(PLStream *pls): plctrl.c plGetFam(PLStream *pls): plctrl.c

plGetFlt

plGetFlt(): plctrl.c plplot::plGetFlt()plGetFlt(): plctrl.c

plGetInt

plGetInt(): plctrl.c plplot::plGetInt()plGetInt(): plctrl.c

plGetName

plGetName(): plctrl.c plplot::plGetName()plGetName(): plctrl.c

plgfamplplotc

plgfam_impl

plplot::plgfam::plgfam_impl()plplot::plgfam_impl()

plgfamCmd

plgfamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgfamCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgfciplplotc

plgfci_impl

plplot::plgfci::plgfci_impl()plplot::plgfci_impl()

plgfciCmd

plgfciCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgfciCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgfile

plgfile(FILE **p_file): plcore.c plgfile(FILE **p_file): plcore.c

plgFileDevs

plgFileDevs(): plcore.c plplot::plgFileDevs()plgFileDevs(): plcore.c

plgfnam

plplot::plgfnam()plplotc.plgfnam()

plgfnam_impl

plplot::plgfnam::plgfnam_impl()plplot::plgfnam_impl()

plgfnamCmd

plgfnamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgfnamCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgfontplplotc

plgfont_impl

plplot::plgfont::plgfont_impl()plplot::plgfont_impl()

plgfontCmd

plgfontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgfontCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plGinInit

plGinInit(PLGraphicsIn *gin): plctrl.c plGinInit(PLGraphicsIn *gin): plctrl.c

plglevelplplotc

plglevel_impl

plplot::plglevel::plglevel_impl()plplot::plglevel_impl()

plglevelCmd

plglevelCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plglevelCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgpageplplotc

plgpageCmd

plgpageCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgpageCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgpls

plgpls(PLStream **p_pls): plcore.c plgpls(PLStream **p_pls): plcore.c

plgraplplotc

plgra_impl

plplot::plgra::plgra_impl()plplot::plgra_impl()

plgraCmd

plgraCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgraCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgradient

plplot::plgradient()plplotc.plgradient()

plgradient_softplgradient.c

plgradientCmd

plgradientCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgradientCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

PLGraphicsIn_swigregisterplplotcPYTHON_wrap.c

plgrid3plot3d.c

plgriddata

plplot::plgriddata()plplotc.plgriddata()

plgriddataCmd

plgriddataCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plgriddataCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plgspaplplotc

plgspaCmd

plgspaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgspaCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgstrmplplotc

plgstrm_impl

plplot::plgstrm::plgstrm_impl()plplot::plgstrm_impl()

plgstrmCmd

plgstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgstrmCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgver

plplot::plgver()plplotc.plgver()

plgver_impl

plplot::plgver::plgver_impl()plplot::plgver_impl()

plgverCmd

plgverCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgverCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgvpdplplotc

plgvpdCmd

plgvpdCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgvpdCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgvpsppllegend.c

plgvpwplplotc

plgvpwCmd

plgvpwCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgvpwCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgwidthplplot_impl.c

plgxaxplplotc

plgxax_impl

plplot::plgxax::plgxax_impl()plplot::plgxax_impl()

plgxaxCmd

plgxaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgxaxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgyaxplplotc

plgyax_impl

plplot::plgyax::plgyax_impl()plplot::plgyax_impl()

plgyaxCmd

plgyaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgyaxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plgzaxplplotc

plgzax_impl

plplot::plgzax::plgzax_impl()plplot::plgzax_impl()

plgzaxCmd

plgzaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plgzaxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plHelpDrvOpts

plHelpDrvOpts(DrvOpt *acc_opt): plargs.c plHelpDrvOpts(DrvOpt *): plargs.c

plhershey2unicode

plhershey2unicode(int in): plsym.c plhershey2unicode(int in): plsym.c

plhist

plplot::plhist()plplotc.plhist()

plhistCmd

plhistCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plhistCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plhlsrgbplplotc

plhlsrgbCmd

plhlsrgbCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plhlsrgbCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plHost_IDpltcl.h

plhrsh

plhrsh(PLINT ch, PLINT x, PLINT y): plsym.c plhrsh(PLINT ch, PLINT x, PLINT y): plsym.c

plhrsh2plsym.c

plimage

plplot::plimage()plplotc.plimage()

plimageCmd

plimageCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plimageCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plimagefr

plplot::plimagefr(PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, pltr_func pltr=null, PLPointer pltr_data=null)plplot::plimagefr(PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLcGrid cgrid)plplot::plimagefr(PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLcGrid2 cgrid2)plplotc.plimagefr()

plimagefr_nullplimage.c

plimagefrCmd

plimagefrCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plimagefrCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plimageslow

plimageslow(PLFLT *idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT ymin, PLFLT dx, PLFLT dy, PLTRANSFORM_callback pltr, PLPointer pltr_data): plimage.c plimageslow(PLFLT *idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT ymin, PLFLT dx, PLFLT dy, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data): plplotP.h

plInBuildTree

plInBuildTree(): plcore.c plInBuildTree(void): plcore.c

plinitplplotc

plinit_impl

plplot::plinit::plinit_impl()plplot::plinit_impl()

plinitCmd

plinitCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plinitCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plInitDispatchTable

plInitDispatchTable(): plcore.c plInitDispatchTable(void): plcore.h

plio_fgets

plio_fgets(char *buf, int size, FILE *stream): plstdio.c plio_fgets(char *, int, FILE *): plstdio.c

plio_fread

plio_fread(void *buf, size_t size, size_t nmemb, FILE *stream): plstdio.c plio_fread(void *, size_t, size_t, FILE *): plstdio.c

plio_fwrite

plio_fwrite(void *buf, size_t size, size_t nmemb, FILE *stream): plstdio.c plio_fwrite(void *, size_t, size_t, FILE *): plstdio.c

pljoinplplotc

pljoinCmd

pljoinCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pljoinCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pllab

plplot::pllab()plplotc.pllab()

pllab_impl

plplot::pllab::pllab_impl()plplot::pllab_impl()

pllabCmd

pllabCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pllabCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pllabelerf2c

plplot_double::pllabelerf2c()plplot_single::pllabelerf2c()

pllabelerf2c_data

plplot_double::pllabelerf2c_data()plplot_single::pllabelerf2c_data()

pllclpplline.c

pllegend

plplot::pllegend()plplotc.pllegend()

pllegendCmd

pllegendCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c pllegendCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

pllib_devinit

pllib_devinit(): plcore.c pllib_devinit(void): plcore.c

pllib_init

pllib_init(): plcore.c pllib_init(void): plcore.c

plLibOpen

plLibOpen(PLCHAR_VECTOR fn): plctrl.c plLibOpen(PLCHAR_VECTOR fn): plctrl.c

plLibOpenPdfstrm

plLibOpenPdfstrm(PLCHAR_VECTOR fn): plctrl.c plLibOpenPdfstrm(const char *fn): plctrl.c

pllightsourceplplotc

pllightsourceCmd

pllightsourceCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pllightsourceCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plline

plplot::plline()plplotc.plline()

plline3

plplot::plline3()plplotc.plline3()

plline3Cmd

plline3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plline3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pllineCmd

pllineCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pllineCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plLoadDriver

plLoadDriver(void): plcore.c plLoadDriver(void): plcore.h

pllstyplplotc

pllsty_impl

plplot::pllsty::pllsty_impl()plplot::pllsty_impl()

pllstyCmd

pllstyCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pllstyCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plmap

plmap(): plmap.c plplot::plmap()plplotc.plmap()

plmapCmd

plmapCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmapCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plmapfill

plmapfill(): plmap.c plplot::plmapfill()plplotc.plmapfill()

plmapfillCmd

plmapfillCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmapfillCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plmapformf2c

plplot_double::plmapformf2c()plplot_single::plmapformf2c()

plmapline

plmapline(): plmap.c plplot::plmapline()plplotc.plmapline()

plmaplineCmd

plmaplineCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmaplineCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plmapstring

plmapstring(): plmap.c plplot::plmapstring()plplotc.plmapstring()

plmapstringCmd

plmapstringCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmapstringCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plmaptex

plmaptex(): plmap.c plplot::plmaptex()plplotc.plmaptex()

plmaptexCmd

plmaptexCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmaptexCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

PLMemoryMap

PLMemoryMap::PLMemoryMap()PLMemoryMap::PLMemoryMap(const char *name, PLINT size, bool mustExist, bool mustNotExist)

plMergeOpts

plMergeOpts(): plargs.c plplot::plMergeOpts()plMergeOpts(): plargs.c

plmeridians

plmeridians(): plmap.c plplotc.plmeridians()

plmeridiansCmd

plmeridiansCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmeridiansCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plmesh

plplot::plmesh()plplotc.plmesh()

plmeshc

plplot::plmeshc()plplotc.plmeshc()

plmeshcCmd

plmeshcCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmeshcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plmeshCmd

plmeshCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plmeshCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plMinMax2dGrid

plMinMax2dGrid(): plmem.c plplot::plMinMax2dGrid(PLFLT[][] f, out PLFLT fmax, out PLFLT fmin)plplot::plMinMax2dGrid(PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin)plMinMax2dGrid(): plplot.h plplotc.plMinMax2dGrid()

plmkstrmplplotc

plmkstrm_impl

plplot::plmkstrm::plmkstrm_impl()plplot::plmkstrm_impl()

plmkstrmCmd

plmkstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plmkstrmCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plmtex

plplot::plmtex()plplotc.plmtex()

plmtex3

plplot::plmtex3()plplotc.plmtex3()

plmtex3Cmd

plmtex3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plmtex3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plmtexCmd

plmtexCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plmtexCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

PLNamedMutex

PLNamedMutex::PLNamedMutex()PLNamedMutex::PLNamedMutex(const char *name, bool aquireOnCreate=false)

PLNamedMutexLocker

PLNamedMutexLocker::PLNamedMutexLocker(PLNamedMutex *mutex)PLNamedMutexLocker::PLNamedMutexLocker()PLNamedMutexLocker::PLNamedMutexLocker(const PLNamedMutexLocker &)

plnxtvplot3d.c

plnxtvhiplot3d.c

plnxtvhi_drawplot3d.c

plnxtvloplot3d.c

plOpenFile

plOpenFile(PLStream *pls): plctrl.c plOpenFile(PLStream *pls): plctrl.c

plOptUsage

plOptUsage(): plargs.c plplot::plOptUsage()plOptUsage(): plargs.c plplotc.plOptUsage()

plot3d

plstream::plot3d()plplot::plot3d()plplotc.plot3d()

plot3dc

plstream::plot3dc()plplot::plot3dc()plplotc.plot3dc()

plot3dcCmd

plot3dcCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plot3dcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plot3dcl

plstream::plot3dcl()plplot::plot3dcl()plplotc.plot3dcl()

plot3dCmd

plot3dCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plot3dCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plP_affine_identity

plP_affine_identity(PLFLT *affine_vector): plaffine.c plP_affine_identity(PLFLT *affine_vector): plaffine.c

plP_affine_multiply

plP_affine_multiply(PLFLT *affine_vectorA, PLFLT_VECTOR affine_vectorB, PLFLT_VECTOR affine_vectorC): plaffine.c plP_affine_multiply(PLFLT *affine_vectorA, PLFLT_VECTOR affine_vectorB, PLFLT_VECTOR affine_vectorC): plaffine.c

plP_affine_rotate

plP_affine_rotate(PLFLT *affine_vector, PLFLT angle): plaffine.c plP_affine_rotate(PLFLT *affine_vector, PLFLT angle): plaffine.c

plP_affine_scale

plP_affine_scale(PLFLT *affine_vector, PLFLT xscale, PLFLT yscale): plaffine.c plP_affine_scale(PLFLT *affine_vector, PLFLT xscale, PLFLT yscale): plaffine.c

plP_affine_translate

plP_affine_translate(PLFLT *affine_vector, PLFLT xtranslate, PLFLT ytranslate): plaffine.c plP_affine_translate(PLFLT *affine_vector, PLFLT xtranslate, PLFLT ytranslate): plaffine.c

plP_affine_xskew

plP_affine_xskew(PLFLT *affine_vector, PLFLT angle): plaffine.c plP_affine_xskew(PLFLT *affine_vector, PLFLT angle): plaffine.c

plP_affine_yskew

plP_affine_yskew(PLFLT *affine_vector, PLFLT angle): plaffine.c plP_affine_yskew(PLFLT *affine_vector, PLFLT angle): plaffine.c

plP_bop

plP_bop(void): plcore.c plP_bop(void): plcore.c

plP_checkdriverinit

plP_checkdriverinit(char *names): plcore.c plP_checkdriverinit(char *names): plcore.c

plP_clip_poly

plP_clip_poly(int Ni, PLFLT *Vi[3], int axis, PLFLT dir, PLFLT offset): plot3d.c plP_clip_poly(int Ni, PLFLT *Vi[3], int axis, PLFLT dir, PLFLT offset): plot3d.c

plP_clipline

plP_clipline(PLINT *p_x1, PLINT *p_y1, PLINT *p_x2, PLINT *p_y2, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax): plline.c plP_clipline(PLINT *p_x1, PLINT *p_y1, PLINT *p_x2, PLINT *p_y2, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax): plline.c

plP_dcmmx

plP_dcmmx(PLFLT x): plcvt.c plP_dcmmx(PLFLT x): plcvt.c

plP_dcmmy

plP_dcmmy(PLFLT y): plcvt.c plP_dcmmy(PLFLT y): plcvt.c

plP_dcpcx

plP_dcpcx(PLFLT x): plcvt.c plP_dcpcx(PLFLT x): plcvt.c

plP_dcpcy

plP_dcpcy(PLFLT y): plcvt.c plP_dcpcy(PLFLT y): plcvt.c

plP_dcscx

plP_dcscx(PLFLT x): plcvt.c plP_dcscx(PLFLT x): plcvt.c

plP_dcscy

plP_dcscy(PLFLT y): plcvt.c plP_dcscy(PLFLT y): plcvt.c

plP_default_label

plP_default_label(PLINT axis, PLFLT value, char *string, PLINT len, void *data): plbox.c plP_default_label(PLINT PL_UNUSED(axis), PLFLT value, char *string, PLINT len, void *data): plbox.c

plP_default_label_log

plP_default_label_log(PLINT axis, PLFLT value, char *string, PLINT len, void *data): plbox.c plP_default_label_log(PLINT PL_UNUSED(axis), PLFLT value, char *string, PLINT len, void *PL_UNUSED(data)): plbox.c

plP_default_label_log_fixed

plP_default_label_log_fixed(PLINT axis, PLFLT value, char *string, PLINT len, void *data): plbox.c plP_default_label_log_fixed(PLINT PL_UNUSED(axis), PLFLT value, char *string, PLINT len, void *PL_UNUSED(data)): plbox.c

plP_draphy

plP_draphy(PLINT x, PLINT y): plline.c plP_draphy(PLINT x, PLINT y): plline.c

plP_draphy_poly

plP_draphy_poly(PLINT *x, PLINT *y, PLINT n): plline.c plP_draphy_poly(PLINT *x, PLINT *y, PLINT n): plline.c

plP_draw3dplot3d.c

plP_drawor

plP_drawor(PLFLT x, PLFLT y): plline.c plP_drawor(PLFLT x, PLFLT y): plline.c

plP_drawor_poly

plP_drawor_poly(PLFLT_VECTOR x, PLFLT_VECTOR y, PLINT n): plline.c plP_drawor_poly(PLFLT_VECTOR x, PLFLT_VECTOR y, PLINT n): plline.c

plP_eop

plP_eop(void): plcore.c plP_eop(void): plcore.c

plP_esc

plP_esc(PLINT op, void *ptr): plcore.c plP_esc(PLINT op, void *ptr): plcore.c

plP_FCI2FontName

plP_FCI2FontName(PLUNICODE fci, const FCI_to_FontName_Table lookup[], const int nlookup): plsym.c plP_FCI2FontName(PLUNICODE fci, const FCI_to_FontName_Table lookup[], const int nlookup): plsym.c

plP_fci2hex

plP_fci2hex(PLUNICODE fci, unsigned char *phexdigit, unsigned char hexpower): plcore.c plP_fci2hex(PLUNICODE fci, unsigned char *phexdigit, unsigned char hexpower): plcore.c

plP_fill

plP_fill(short *x, short *y, PLINT npts): plcore.c plP_fill(short *x, short *y, PLINT npts): plcore.c

plP_FreeDrvOpts

plP_FreeDrvOpts(): plargs.c plP_FreeDrvOpts(void): plargs.c

plP_gclp

plP_gclp(PLINT *p_ixmin, PLINT *p_ixmax, PLINT *p_iymin, PLINT *p_iymax): plcore.c plP_gclp(PLINT *p_ixmin, PLINT *p_ixmax, PLINT *p_iymin, PLINT *p_iymax): plcore.c

plP_gdom

plP_gdom(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax): plcore.c plP_gdom(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax): plcore.c

plP_getinitdriverlist

plP_getinitdriverlist(char *names): plcore.c plP_getinitdriverlist(char *names): plcore.c

plP_getmember

plP_getmember(PLStream *pls): plctrl.c plP_getmember(PLStream *pls): plctrl.c

plP_gphy

plP_gphy(PLINT *p_ixmin, PLINT *p_ixmax, PLINT *p_iymin, PLINT *p_iymax): plcore.c plP_gphy(PLINT *p_ixmin, PLINT *p_ixmax, PLINT *p_iymin, PLINT *p_iymax): plcore.c

plP_gpixmm

plP_gpixmm(PLFLT *p_x, PLFLT *p_y): plcore.c plP_gpixmm(PLFLT *p_x, PLFLT *p_y): plcore.c

plP_gprec

plP_gprec(PLINT *p_setp, PLINT *p_prec): plcore.c plP_gprec(PLINT *p_setp, PLINT *p_prec): plcore.c

plP_gradient

plP_gradient(short *x, short *y, PLINT npts): plcore.c plP_gradient(short *x, short *y, PLINT npts): plcore.c

plP_grange

plP_grange(PLFLT *p_zscl, PLFLT *p_zmin, PLFLT *p_zmax): plcore.c plP_grange(PLFLT *p_zscl, PLFLT *p_zmin, PLFLT *p_zmax): plcore.c

plP_gsub

plP_gsub(PLINT *p_nx, PLINT *p_ny, PLINT *p_cs): plcore.c plP_gsub(PLINT *p_nx, PLINT *p_ny, PLINT *p_cs): plcore.c

plP_gtimefmt

plP_gtimefmt(): plcore.c plP_gtimefmt(void): plcore.c

plP_gw3wc

plP_gw3wc(PLFLT *p_dxx, PLFLT *p_dxy, PLFLT *p_dyx, PLFLT *p_dyy, PLFLT *p_dyz): plcore.c plP_gw3wc(PLFLT *p_dxx, PLFLT *p_dxy, PLFLT *p_dyx, PLFLT *p_dyy, PLFLT *p_dyz): plcore.c

plP_gzback

plP_gzback(PLINT **zbf, PLINT **zbc, PLFLT **zbt, PLFLT **zbw): plot3d.c plP_gzback(PLINT **zbf, PLINT **zbc, PLFLT **zbt, PLFLT **zbw): plot3d.c

plP_hex2fci

plP_hex2fci(unsigned char hexdigit, unsigned char hexpower, PLUNICODE *pfci): plcore.c plP_hex2fci(unsigned char hexdigit, unsigned char hexpower, PLUNICODE *pfci): plcore.c

plP_image

plP_image(PLFLT *z, PLINT nx, PLINT ny, PLFLT xmin, PLFLT ymin, PLFLT dx, PLFLT dy, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data): plcore.c plP_image(PLFLT *z, PLINT nx, PLINT ny, PLFLT xmin, PLFLT ymin, PLFLT dx, PLFLT dy, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data): plcore.c

plP_init

plP_init(void): plcore.c plP_init(void): plcore.c

plP_line

plP_line(short *x, short *y): plcore.c plP_line(short *x, short *y): plcore.c

plP_mmdcx

plP_mmdcx(PLFLT x): plcvt.c plP_mmdcx(PLFLT x): plcvt.c

plP_mmdcy

plP_mmdcy(PLFLT y): plcvt.c plP_mmdcy(PLFLT y): plcvt.c

plP_mmpcx

plP_mmpcx(PLFLT x): plcvt.c plP_mmpcx(PLFLT x): plcvt.c

plP_mmpcy

plP_mmpcy(PLFLT y): plcvt.c plP_mmpcy(PLFLT y): plcvt.c

plP_movphy

plP_movphy(PLINT x, PLINT y): plline.c plP_movphy(PLINT x, PLINT y): plline.c

plP_movwor

plP_movwor(PLFLT x, PLFLT y): plline.c plP_movwor(PLFLT x, PLFLT y): plline.c

plP_pcdcx

plP_pcdcx(PLINT x): plcvt.c plP_pcdcx(PLINT x): plcvt.c

plP_pcdcy

plP_pcdcy(PLINT y): plcvt.c plP_pcdcy(PLINT y): plcvt.c

plP_pcwcxplcont.c

plP_pcwcyplcont.c

plP_plfclp

plP_plfclp(PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void(*draw)(short *, short *, PLINT)): plfill.c plP_plfclp(PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void(*draw)(short *, short *, PLINT)): plfill.c

plP_pllclp

plP_pllclp(PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void(*draw)(short *, short *, PLINT)): plline.c plP_pllclp(PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void(*draw)(short *, short *, PLINT)): plline.c

plP_plotvectplvect.c

plP_pointinpolygon

plP_pointinpolygon(PLINT n, PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT xp, PLFLT yp): plfill.c plP_pointinpolygon(PLINT n, PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT xp, PLFLT yp): plfill.c

plP_polyline

plP_polyline(short *x, short *y, PLINT npts): plcore.c plP_polyline(short *x, short *y, PLINT npts): plcore.c

plP_scdcx

plP_scdcx(PLFLT x): plcvt.c plP_scdcx(PLFLT x): plcvt.c

plP_scdcy

plP_scdcy(PLFLT y): plcvt.c plP_scdcy(PLFLT y): plcvt.c

plP_sclp

plP_sclp(PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax): plcore.c plP_sclp(PLINT ixmin, PLINT ixmax, PLINT iymin, PLINT iymax): plcore.c

plP_script_scale

plP_script_scale(PLBOOL ifupper, PLINT *level, PLFLT *old_scale, PLFLT *scale, PLFLT *old_offset, PLFLT *offset): plsym.c plP_script_scale(PLBOOL ifupper, PLINT *level, PLFLT *old_scale, PLFLT *scale, PLFLT *old_offset, PLFLT *offset): plsym.c

plP_setphy

plP_setphy(PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax): plcore.c plP_setphy(PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax): plcore.c

plP_setpxl

plP_setpxl(PLFLT xpmm, PLFLT ypmm): plcore.c plP_setpxl(PLFLT xpmm0, PLFLT ypmm0): plcore.c

plP_setsub

plP_setsub(void): plpage.c plP_setsub(void): plpage.c

plP_sfnam

plP_sfnam(PLStream *pls, PLCHAR_VECTOR fnam): plctrl.c plP_sfnam(PLStream *pls, const char *fnam): plctrl.c

plP_ssub

plP_ssub(PLINT nx, PLINT ny, PLINT cs): plcore.c plP_ssub(PLINT nx, PLINT ny, PLINT cs): plcore.c

plP_state

plP_state(PLINT op): plcore.c plP_state(PLINT op): plcore.c

plP_stindex

plP_stindex(PLCHAR_VECTOR str1, PLCHAR_VECTOR str2): plsym.c plP_stindex(PLCHAR_VECTOR str1, PLCHAR_VECTOR str2): plsym.c

plP_strpos

plP_strpos(PLCHAR_VECTOR str, int chr): plsym.c plP_strpos(PLCHAR_VECTOR str, int chr): plsym.c

plP_stsearch

plP_stsearch(PLCHAR_VECTOR str, int chr): plsym.c plP_stsearch(PLCHAR_VECTOR str, int chr): plsym.c

plP_subpInit

plP_subpInit(void): plpage.c plP_subpInit(void): plpage.c

plP_swin

plP_swin(PLWindow *plwin): plcore.c plP_swin(PLWindow *plwin): plcore.c

plP_text

plP_text(PLINT base, PLFLT just, PLFLT *xform, PLINT x, PLINT y, PLINT refx, PLINT refy, PLCHAR_VECTOR string): plcore.c plP_text(PLINT base, PLFLT just, PLFLT *xform, PLINT x, PLINT y, PLINT refx, PLINT refy, PLCHAR_VECTOR string): plcore.c

plP_tidy

plP_tidy(void): plcore.c plP_tidy(void): plcore.c

plP_w3wcx

plP_w3wcx(PLFLT x, PLFLT y, PLFLT PL_UNUSED(z)): plcvt.c plP_w3wcx(PLFLT x, PLFLT y, PLFLT z): plplotP.h

plP_w3wcy

plP_w3wcy(PLFLT x, PLFLT y, PLFLT z): plcvt.c plP_w3wcy(PLFLT x, PLFLT y, PLFLT z): plcvt.c

plP_w3wcz

plP_w3wcz(PLFLT x, PLFLT y, PLFLT z): plcvt.c plP_w3wcz(PLFLT x, PLFLT y, PLFLT z): plcvt.c

plP_wait

plP_wait(void): plcore.c plP_wait(void): plcore.c

plP_wcdcx

plP_wcdcx(PLFLT x): plcvt.c plP_wcdcx(PLFLT x): plcvt.c

plP_wcdcy

plP_wcdcy(PLFLT y): plcvt.c plP_wcdcy(PLFLT y): plcvt.c

plP_wcmmx

plP_wcmmx(PLFLT x): plcvt.c plP_wcmmx(PLFLT x): plcvt.c

plP_wcmmy

plP_wcmmy(PLFLT y): plcvt.c plP_wcmmy(PLFLT y): plcvt.c

plP_wcpcx

plP_wcpcx(PLFLT x): plcvt.c plP_wcpcx(PLFLT x): plcvt.c

plP_wcpcy

plP_wcpcy(PLFLT y): plcvt.c plP_wcpcy(PLFLT y): plcvt.c

plP_xgvpw

plP_xgvpw(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax): plcore.c plP_xgvpw(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax): plcore.c

plParseDrvOpts

plParseDrvOpts(DrvOpt *acc_opt): plargs.c plParseDrvOpts(DrvOpt *): plargs.c

plparseopts

plplot::plparseopts()plplotc.plparseopts()

plparseopts_brief

plplot::plparseopts::plparseopts_brief()plplot::plparseopts_brief()

plparseopts_dynamic

plplot::plparseopts::plparseopts_dynamic()plplot::plparseopts_dynamic()

plparseopts_static

plplot::plparseopts::plparseopts_static()plplot::plparseopts_static()

plparseopts_static_length

plplot::plparseopts::plparseopts_static_length()plplot::plparseopts_static_length()

plpat

plplot::plpat()plplotc.plpat()

plpat_impl

plplot::plpat::plpat_impl()plplot::plpat_impl()

plpatCmd

plpatCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plpatCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plpathplplotc

plpathCmd

plpathCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plpathCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plplot_check_nonzero_resultplplot_impl.c

plplot_private_pltrplplot_private_exposed

Plplotter_InitPlplotter_Init.c

PlplotterAtBopplplotter.c

PlplotterAtEopplplotter.c

PlPlotterButtonPressEHplplotter.c

plPlotterCmd

plPlotterCmd(ClientData clientData, Tcl_Interp *interp, int argc, const char **argv): plserver.h plPlotterCmd(ClientData, Tcl_Interp *, int, const char **): plplotter.c plPlotterCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char **argv): plplotter.c

PlPlotterConfigureEH

PlPlotterConfigureEH(ClientData, XEvent *): plplotter.c PlPlotterConfigureEH(ClientData clientData, register XEvent *eventPtr): plplotter.c

PlPlotterEnterEHplplotter.c

PlPlotterExposeEH

PlPlotterExposeEH(ClientData, XEvent *): plplotter.c PlPlotterExposeEH(ClientData clientData, register XEvent *eventPtr): plplotter.c

PlPlotterFirstInitplplotter.c

PlPlotterInitplplotter.c

PlPlotterLeaveEH

PlPlotterLeaveEH(ClientData, register XEvent *): plplotter.c PlPlotterLeaveEH(ClientData clientData, register XEvent *PL_UNUSED(eventPtr)): plplotter.c

PlPlotterMotionEHplplotter.c

PlPlotterWidgetCmdplplotter.c

plpoin

plplot::plpoin()plplotc.plpoin()

plpoin3

plplot::plpoin3()plplotc.plpoin3()

plpoin3Cmd

plpoin3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plpoin3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plpoinCmd

plpoinCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plpoinCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plpoly3

plplot::plpoly3()plplotc.plpoly3()

plpoly3Cmd

plpoly3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plpoly3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plprecplplotc

plprec_impl

plplot::plprec::plprec_impl()plplot::plprec_impl()

plprecCmd

plprecCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plprecCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plPrepOutputHandler

plPrepOutputHandler(Tcl_Interp *interp, int code, int tty): tclMain.c plPrepOutputHandler(Tcl_Interp *PL_UNUSED(interp), int PL_UNUSED(code), int PL_UNUSED(tty)): tclMain.c

plpstyplplotc

plpsty_impl

plplot::plpsty::plpsty_impl()plplot::plpsty_impl()

plpstyCmd

plpstyCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plpstyCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plptex

plplot::plptex()plplotc.plptex()

plptex3

plplot::plptex3()plplotc.plptex3()

plptex3Cmd

plptex3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plptex3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plptexCmd

plptexCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plptexCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plr_bopplr.c

plr_eop

plr_eop(PLRDev *plr): plr.c plr_eop(PLRDev *PL_UNUSED(plr)): plr.c

plr_escplr.c

plr_getplr.c

plr_initplr.c

plr_lineplr.c

plr_process

plr_process(PLRDev *plr): plr.c plr_process(PLRDev *plr): plr.c

plr_process1plr.c

plr_start

plr_start(PLRDev *plr): plr.c plr_start(PLRDev *plr): plr.c

plr_stateplr.c

plr_ungetplr.c

plranddplplotc

plrandd_impl

plplot_double::plrandd::plrandd_impl()plplot_double::plrandd_impl()

plranddCmd

plranddCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plranddCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char **argv): tclAPI.c

plreadmetafile

plreadmetafile(char *infile): plmetafile.c plreadmetafile(char *infile): plmetafile.c

plRemakePlot

plRemakePlot(PLStream *pls): plbuf.c plRemakePlot(PLStream *): plbuf.c

plreplotplplotc

plreplot_impl

plplot::plreplot::plreplot_impl()plplot::plreplot_impl()

plreplotCmd

plreplotCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plreplotCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plresc_fillplr.c

plResetOpts

plResetOpts(): plargs.c plplot::plResetOpts()plResetOpts(): plargs.c plplotc.plResetOpts()

plrestore_locale

plrestore_locale(char *saved_lc_numeric_locale): plctrl.c plrestore_locale(char *save_lc_numeric_locale): plctrl.c

plrgbhlsplplotc

plrgbhlsCmd

plrgbhlsCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plrgbhlsCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plRotationShear

plRotationShear(PLFLT *xFormMatrix, PLFLT *rotation, PLFLT *shear, PLFLT *stride): plot3d.c plRotationShear(PLFLT *xFormMatrix, PLFLT *rotation, PLFLT *shear, PLFLT *stride): plot3d.c

plRotPhy

plRotPhy(PLINT orient, PLINT xmin, PLINT ymin, PLINT xmax, PLINT ymax, PLINT *px, PLINT *py): plctrl.c plRotPhy(PLINT orient, PLINT xmin, PLINT ymin, PLINT xmax, PLINT ymax, PLINT *px, PLINT *py): plctrl.c

pls_auto_path

pls_auto_path(Tcl_Interp *interp): tclAPI.c pls_auto_path(Tcl_Interp *interp): tclAPI.c

plsabort

plsabort(): plctrl.c plplot::plsabort()plsabort(): plctrl.c

plsave_set_locale

plsave_set_locale(void): plctrl.c plsave_set_locale(void): plctrl.c

plsbopH

plsbopH(): plcore.c plplot::plsbopH()plsbopH(): plcore.c

plsButtonEH

plsButtonEH(): plcore.c plplot::plsButtonEH()plsButtonEH(): plcore.c

plschrplplotc

plschrCmd

plschrCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plschrCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap0

plplot::plscmap0()plplotc.plscmap0()

plscmap0_impl

plplot::plscmap0::plscmap0_impl()plplot::plscmap0_impl()

plscmap0a

plplot::plscmap0a()plplotc.plscmap0a()

plscmap0aCmd

plscmap0aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap0aCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap0Cmd

plscmap0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap0Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap0nplplotc

plscmap0n_impl

plplot::plscmap0n::plscmap0n_impl()plplot::plscmap0n_impl()

plscmap0nCmd

plscmap0nCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap0nCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap1

plplot::plscmap1()plplotc.plscmap1()

plscmap1_impl

plplot::plscmap1::plscmap1_impl()plplot::plscmap1_impl()

plscmap1_rangeplplotc

plscmap1_rangeCmd

plscmap1_rangeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap1_rangeCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap1a

plplot::plscmap1a()plplotc.plscmap1a()

plscmap1aCmd

plscmap1aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap1aCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap1Cmd

plscmap1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap1Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap1l

plplot::plscmap1l()plplotc.plscmap1l()

plscmap1la

plplot::plscmap1la()plplotc.plscmap1la()

plscmap1laCmd

plscmap1laCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap1laCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap1lCmd

plscmap1lCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap1lCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscmap1nplplotc

plscmap1n_impl

plplot::plscmap1n::plscmap1n_impl()plplot::plscmap1n_impl()

plscmap1nCmd

plscmap1nCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscmap1nCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscol0plplotc

plscol0_impl

plplot::plscol0::plscol0_impl()plplot::plscol0_impl()

plscol0aplplotc

plscol0aCmd

plscol0aCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscol0aCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscol0Cmd

plscol0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscol0Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscolbgplplotc

plscolbg_impl

plplot::plscolbg::plscolbg_impl()plplot::plscolbg_impl()

plscolbgaplplotc

plscolbgaCmd

plscolbgaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscolbgaCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscolbgCmd

plscolbgCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscolbgCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscolorplplotc

plscolor_impl

plplot::plscolor::plscolor_impl()plplot::plscolor_impl()

plscolorCmd

plscolorCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscolorCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plscompressionplplotc

plscompression_impl

plplot::plscompression::plscompression_impl()plplot::plscompression_impl()

plscompressionCmd

plscompressionCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plscompressionCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdev

plplot::plsdev()plplotc.plsdev()

plsdev_impl

plplot::plsdev::plsdev_impl()plplot::plsdev_impl()

plsdevCmd

plsdevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsdevCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdevdata

plsdevdata(void *data): plcore.c plsdevdata(PLPointer data): plcore.c

plsdidevplplotc

plsdidevCmd

plsdidevCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsdidevCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdimapplplotc

plsdimapCmd

plsdimapCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsdimapCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdioriplplotc

plsdioriCmd

plsdioriCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsdioriCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdipltplplotc

plsdipltCmd

plsdipltCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsdipltCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdiplzplplotc

plsdiplzCmd

plsdiplzCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsdiplzCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsdrawmode_impl

plplot::plsdrawmode::plsdrawmode_impl()plplot::plsdrawmode_impl()

plseedplplotc

plseed_impl

plplot::plseed::plseed_impl()plplot::plseed_impl()

plseedCmd

plseedCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plseedCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plSelectDev

plSelectDev(): plcore.c plSelectDev(void): plcore.h

plseopH

plseopH(): plcore.c plplot::plseopH()plseopH(): plcore.c

plsError

plsError(): plcore.c plplot::plsError()plsError(): plplot.h

plsescplplotc

plsesc_impl

plplot::plsesc::plsesc_impl()plplot::plsesc_impl()

plsescCmd

plsescCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsescCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsetopt

plplot::plsetopt()plplotc.plsetopt()

plsetopt_impl

plplot::plsetopt::plsetopt_impl()plplot::plsetopt_impl()

plsetoptCmd

plsetoptCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plsetoptCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char **argv): tclAPI.c

plSetUsage

plSetUsage(): plargs.c plplot::plSetUsage()plSetUsage(): plargs.c plplotc.plSetUsage()

plsexit

plsexit(): plctrl.c plplot::plsexit()plsexit(): plctrl.c

plsfamplplotc

plsfam_impl

plplot::plsfam::plsfam_impl()plplot::plsfam_impl()

plsfamCmd

plsfamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsfamCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsfciplplotc

plsfci_impl

plplot::plsfci::plsfci_impl()plplot::plsfci_impl()

plsfciCmd

plsfciCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsfciCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsfile

plsfile(FILE *file): plcore.c plsfile(FILE *file): plcore.c

plsfnam

plplot::plsfnam()plplotc.plsfnam()

plsfnam_impl

plplot::plsfnam::plsfnam_impl()plplot::plsfnam_impl()

plsfnamCmd

plsfnamCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsfnamCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsfontplplotc

plsfont_impl

plplot::plsfont::plsfont_impl()plplot::plsfont_impl()

plsfontCmd

plsfontCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsfontCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plshade

plplot::plshade()plplotc.plshade()

plshade_int

plshade_int(PLF2EVAL_callback f2eval, PLPointer f2eval_data, PLF2EVAL_callback c2eval, PLPointer c2eval_data, PLDEFINED_callback defined, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, 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, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data): plshade.c plshade_int(PLF2EVAL_callback f2eval, PLPointer f2eval_data, PLF2EVAL_callback c2eval, PLPointer PL_UNUSED(c2eval_data), PLDEFINED_callback defined, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, 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, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data): plshade.c

plshade_nullplshade.c

plshadeCmd

plshadeCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plshadeCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plshades

plplot::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, pltr_func pltr=null, PLPointer pltr_data=null)plplot::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 PLcGrid cgrid)plplot::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)plplotc.plshades()

plshades_nullplshade.c

plshadesCmd

plshadesCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plshadesCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plside3plot3d.c

plsKeyEH

plsKeyEH(): plcore.c plplot::plsKeyEH()plsKeyEH(): plcore.c

plslabelfuncplplotc

plslabelfunc_impl

plplot_double::plslabelfunc::plslabelfunc_impl()plplot_double::plslabelfunc_impl()

plslabelfunc_impl_data

plplot_double::plslabelfunc::plslabelfunc_impl_data()plplot_double::plslabelfunc_impl_data()

plslabelfunc_impl_null

plplot_double::plslabelfunc::plslabelfunc_impl_null()plplot_double::plslabelfunc_impl_null()

plslabelfuncCmd

plslabelfuncCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plslabelfuncCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plsmajplplotc

plsmajCmd

plsmajCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsmajCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsmemplplotc

plsmem_impl

plplot::plsmem::plsmem_impl()plplot::plsmem_impl()

plsmemaplplotc

plsmema_impl

plplot::plsmema::plsmema_impl()plplot::plsmema_impl()

plsminplplotc

plsminCmd

plsminCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsminCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsnprintf

plsnprintf(char *buffer, int n, PLCHAR_VECTOR format,...): plctrl.c plsnprintf(char *buffer, int n, PLCHAR_VECTOR format,...): plctrl.c

plsnscanf

plsnscanf(PLCHAR_VECTOR buffer, int n, PLCHAR_VECTOR format,...): plctrl.c plsnscanf(PLCHAR_VECTOR buffer, int n, PLCHAR_VECTOR format,...): plctrl.c

plsoriplplotc

plsori_impl

plplot::plsori::plsori_impl()plplot::plsori_impl()

plsoriCmd

plsoriCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsoriCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plspageplplotc

plspageCmd

plspageCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plspageCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plspal0

plplot::plspal0()plplotc.plspal0()

plspal0_impl

plplot::plspal0::plspal0_impl()plplot::plspal0_impl()

plspal0Cmd

plspal0Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plspal0Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plspal1

plplot::plspal1()plplotc.plspal1()

plspal1_impl

plplot::plspal1::plspal1_impl()plplot::plspal1_impl()

plspal1Cmd

plspal1Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plspal1Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plspauseplplotc

plspause_impl

plplot::plspause::plspause_impl()plplot::plspause_impl()

plspauseCmd

plspauseCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plspauseCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsstrmplplotc

plsstrm_impl

plplot::plsstrm::plsstrm_impl()plplot::plsstrm_impl()

plsstrmCmd

plsstrmCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsstrmCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plssubplplotc

plssub_impl

plplot::plssub::plssub_impl()plplot::plssub_impl()

plssubCmd

plssubCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plssubCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plssymplplotc

plssymCmd

plssymCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plssymCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plstarplplotc

plstar_impl

plplot::plstar::plstar_impl()plplot::plstar_impl()

plstarCmd

plstarCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstarCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plstart

plplot::plstart()plplotc.plstart()

plstart_impl

plplot::plstart::plstart_impl()plplot::plstart_impl()

plstartCmd

plstartCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstartCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plStatic2dGrid

plStatic2dGrid(PLFLT_NC_MATRIX zIliffe, PLFLT_VECTOR zStatic, PLINT nx, PLINT ny): plmem.c plStatic2dGrid(PLFLT_NC_MATRIX zIliffe, PLFLT_VECTOR zStatic, PLINT nx, PLINT ny): plmem.c

plstik

plstik(PLFLT mx, PLFLT my, PLFLT dx, PLFLT dy): pltick.c plstik(PLFLT mx, PLFLT my, PLFLT dx, PLFLT dy): pltick.c

plstr

plstr(PLINT base, PLFLT *xform, PLINT refx, PLINT refy, PLCHAR_VECTOR string): plsym.c plstr(PLINT base, PLFLT *xform, PLINT refx, PLINT refy, PLCHAR_VECTOR string): plsym.c

plstransformplplotc

plstransform_impl

plplot_double::plstransform::plstransform_impl()plplot_double::plstransform_impl()

plstransform_impl_data

plplot_double::plstransform::plstransform_impl_data()plplot_double::plstransform_impl_data()

plstransform_impl_null

plplot_double::plstransform::plstransform_impl_null()plplot_double::plstransform_impl_null()

plstransformCmd

plstransformCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plstransformCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plstrdup

plstrdup(PLCHAR_VECTOR src): plctrl.c plstrdup(PLCHAR_VECTOR src): plctrl.c

plstream

plstream::plstream(const plstream &)plstream::plstream(void)plstream::plstream(plstream *pls)plstream::plstream(PLS::stream_id sid, PLINT strm=0)plstream::plstream(PLINT _stream)plstream::plstream(PLINT nx, PLINT ny, const char *driver=NULL, const char *file=NULL)plstream::plstream(PLINT nx, PLINT ny, PLINT r, PLINT g, PLINT b, const char *driver=NULL, const char *file=NULL)

plstring

plplot::plstring()plplotc.plstring()

plstring3

plplot::plstring3()plplotc.plstring3()

plstring3Cmd

plstring3Cmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstring3Cmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plstringCmd

plstringCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstringCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plstrip_genplstripc.c

plstrip_legendplstripc.c

plstripaplplotc

plstripaCmd

plstripaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstripaCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plstripc

plplot::plstripc()plplotc.plstripc()

plstripcCmd

plstripcCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plstripcCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plstripdplplotc

plstripd_impl

plplot::plstripd::plstripd_impl()plplot::plstripd_impl()

plstripdCmd

plstripdCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstripdCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plstrl

plstrl(PLCHAR_VECTOR string): plsym.c plstrl(PLCHAR_VECTOR string): plsym.c

plstrm_init

plstrm_init(void): plcore.c plstrm_init(void): plcore.c

plstyl

plplot::plstyl()plplotc.plstyl()

plstyl_impl

plplot::plstyl::plstyl_impl()plplot::plstyl_impl()

plstylCmd

plstylCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plstylCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsurf3d

plplot::plsurf3d()plplotc.plsurf3d()

plsurf3dCmd

plsurf3dCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plsurf3dCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plsurf3dl

plplot::plsurf3dl()plplotc.plsurf3dl()

plsurf3dlCmd

plsurf3dlCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plsurf3dlCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plsvect

plplot::plsvect()plplotc.plsvect()

plsvect_none

plplot::plsvect::plsvect_none()plplot::plsvect_none()

plsvect_nullplvect.c

plsvectCmd

plsvectCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plsvectCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plsvpaplplotc

plsvpaCmd

plsvpaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsvpaCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsxaxplplotc

plsxax_impl

plplot::plsxax::plsxax_impl()plplot::plsxax_impl()

plsxaxCmd

plsxaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsxaxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsxwin

plsxwin(): plcore.c plplot::plsxwin()plsxwin(): plcore.c plplotc.plsxwin()

plsyaxplplotc

plsyax_impl

plplot::plsyax::plsyax_impl()plplot::plsyax_impl()

plsyaxCmd

plsyaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsyaxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plsym

plplot::plsym()plplotc.plsym()

plsymCmd

plsymCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plsymCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plszaxplplotc

plszax_impl

plplot::plszax::plszax_impl()plplot::plszax_impl()

plszaxCmd

plszaxCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plszaxCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plt3zzplot3d.c

Pltcl_Init

Pltcl_Init(Tcl_Interp *interp): tclAPI.c Pltcl_Init(Tcl_Interp *interp): tclAPI.c

plTclCmd

plTclCmd(char *cmdlist, Tcl_Interp *interp, int argc, const char **argv): tclAPI.c plTclCmd(char *cmdlist, Tcl_Interp *interp, int argc, const char **argv): tclAPI.c

plTclCmd_InittclAPI.c

pltclMain

pltclMain(int argc, char **argv, char *RcFileName, int(*AppInit)(Tcl_Interp *interp)): pltcl.h pltclMain(int argc, char **argv, char *PL_UNUSED(RcFileName), int(*appInitProc)(Tcl_Interp *interp)): tclMain.c

pltextplplotc

pltext_impl

plplot::pltext::pltext_impl()plplot::pltext_impl()

pltextCmd

pltextCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pltextCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

pltimefmt

plplot::pltimefmt()plplotc.pltimefmt()

pltimefmt_impl

plplot::pltimefmt::pltimefmt_impl()plplot::pltimefmt_impl()

pltimefmtCmd

pltimefmtCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c pltimefmtCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

Pltk_Init

Pltk_Init(Tcl_Interp *interp): Pltk_Init.c Pltk_Init(Tcl_Interp *interp): Pltk_Init.c Pltk_Init(Tcl_Interp *interp): tkshell.c

pltkMain

pltkMain(int argc, const char **argv, char *RcFileName, int(*AppInit)(Tcl_Interp *interp)): tkMain.c pltkMain(int argc, const char **argv, char *RcFileName, int(*AppInit)(Tcl_Interp *interp)): tkMain.c

pltkwin_setBGFGpltkwd.h

pltr0

pltr0(): plcont.c plplot::pltr0()pltr0(): plplot.h plplotc.pltr0()

pltr0fplplot

pltr1

pltr1(): plcont.c plplot::pltr1()pltr1(): plplot.h plplotc.pltr1()

pltr2

pltr2(): plcont.c plplot::pltr2()pltr2(): plplot.h plplotc.pltr2()

pltr2f

pltr2f(): plcont.c plplot::pltr2f()pltr2f(): plplot.h

pltr2p

pltr2p(): plcont.c plplot::pltr2p()pltr2p(): plplot.h

pltransformf2c

plplot_double::pltransformf2c()plplot_single::pltransformf2c()

pltransformf2c_data

plplot_double::pltransformf2c_data()plplot_single::pltransformf2c_data()

plTranslateCursor

plTranslateCursor(): plpage.c plplot::plTranslateCursor()plTranslateCursor(): plpage.c

plunicode2type1ps.c

plvaspplplotc

plvaspCmd

plvaspCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plvaspCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plvect

plplot::plvect(PLFLT[][] u, PLFLT[][] v, PLFLT scale, pltr_func pltr=null, PLPointer pltr_data=null)plplot::plvect(PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid cgrid)plplot::plvect(PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid2 cgrid2)plplotc.plvect()

plvectCmd

plvectCmd(ClientData, Tcl_Interp *, int, const char **): tclAPI.c plvectCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclAPI.c

plvpasplplotc

plvpasCmd

plvpasCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plvpasCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plvporplplotc

plvporCmd

plvporCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plvporCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plvstaplplotc

plvsta_impl

plplot::plvsta::plvsta_impl()plplot::plvsta_impl()

plvstaCmd

plvstaCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plvstaCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plw3dplplotc

plw3dCmd

plw3dCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plw3dCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plWait_Until

plWait_Until(ClientData, Tcl_Interp *, int, const char **): pltcl.h plWait_Until(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int PL_UNUSED(argc), const char **argv): tclAPI.c plWait_Until(ClientData clientData, Tcl_Interp *interp, int argc, char **argv): tkshell.c

plwarn

plwarn(PLCHAR_VECTOR errormsg): plctrl.c plwarn(PLCHAR_VECTOR errormsg): plctrl.c

plwidthplplotc

plwidthCmd

plwidthCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plwidthCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plwindplplotc

plwindCmd

plwindCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plwindCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plwxtik

plwxtik(PLFLT x, PLFLT y, PLBOOL minor, PLBOOL invert): pltick.c plwxtik(PLFLT x, PLFLT y, PLBOOL minor, PLBOOL invert): pltick.c

plwytik

plwytik(PLFLT x, PLFLT y, PLBOOL minor, PLBOOL invert): pltick.c plwytik(PLFLT x, PLFLT y, PLBOOL minor, PLBOOL invert): pltick.c

plxormodplplotc

plxormod_impl

plplot::plxormod::plxormod_impl()plplot::plxormod_impl()

plxormodCmd

plxormodCmd(ClientData PL_UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[]): tclgen.c plxormodCmd(ClientData, Tcl_Interp *, int, const char **): tclgen.h

plxtik

plxtik(PLINT x, PLINT y, PLINT below, PLINT above): pltick.c plxtik(PLINT x, PLINT y, PLINT below, PLINT above): pltick.c

plxybx

plxybx(PLCHAR_VECTOR opt, PLCHAR_VECTOR label, PLINT axis, PLFLT wx1, PLFLT wy1, PLFLT wx2, PLFLT wy2, PLFLT vmin, PLFLT vmax, PLFLT tick, PLINT nsub, PLINT nolast, PLINT *digits): plbox.c plxybx(PLCHAR_VECTOR opt, PLCHAR_VECTOR label, PLINT axis, PLFLT wx1, PLFLT wy1, PLFLT wx2, PLFLT wy2, PLFLT vmin_in, PLFLT vmax_in, PLFLT tick, PLINT nsub, PLINT PL_UNUSED(nolast), PLINT *digits): plbox.c

plxytxplbox.c

plytik

plytik(PLINT x, PLINT y, PLINT left, PLINT right): pltick.c plytik(PLINT x, PLINT y, PLINT left, PLINT right): pltick.c

plzbxplbox.c

plztxplbox.c

poinplstream

poin3plstream

points_generate1

points_generate1(int n, point points[], int nx, int ny, double zoom, int *nout, point **pout): nncommon.c points_generate1(int nin, point pin[], int nx, int ny, double zoom, int *nout, point **pout): nncommon.c

points_generate2

points_generate2(double xmin, double xmax, double ymin, double ymax, int nx, int ny, int *nout, point **pout): nncommon.c points_generate2(double xmin, double xmax, double ymin, double ymax, int nx, int ny, int *nout, point **pout): nncommon.c

points_read

points_read(char *fname, int dim, int *n, point **points): nncommon.c points_read(char *fname, int dim, int *n, point **points): nncommon.c

points_scale

points_scale(int n, point *points, double k): nncommon.c points_scale(int n, point *points, double k): nncommon.c

points_scaletosquare

points_scaletosquare(int n, point *points): nncommon.c points_scaletosquare(int n, point *points): nncommon.c

points_thin

points_thin(int *n, point **points, int nx, int ny): nncommon.c points_thin(int *pn, point **ppoints, int nx, int ny): nncommon.c

poly3plstream

poly_line

poly_line(PLStream *, short *, short *, PLINT): cairo.c poly_line(PLStream *, short *, short *, PLINT, short): svg.c

precplstream

PreDestructorTidy

PlDevice::PreDestructorTidy()wxPLDevice::PreDestructorTidy()

print

octave_swig_type::print()octave_swig_ref::print()octave_swig_packed::print()Print(Tcl_Interp *, PlFrame *, int, const char **): plframe.c Print(Tcl_Interp *interp, register PlFrame *plFramePtr, int PL_UNUSED(argc), const char **PL_UNUSED(argv)): plframe.c Print(Tcl_Interp *, PlPlotter *, int, CONST char **): plplotter.c Print(Tcl_Interp *interp, register PlPlotter *plPlotterPtr, int PL_UNUSED(argc), CONST char **PL_UNUSED(argv)): plplotter.c

print_ieeefpdfutils.c

proc_str

proc_str(PLStream *, EscText *): aqt.c proc_str(PLStream *, EscText *): cairo.c proc_str(PLStream *, EscText *): ps.c proc_str(PLStream *, EscText *): psttf.cc proc_str(PLStream *, EscText *): svg.c

process_bop

process_bop(void *, int *): plframe.c process_bop(void *clientData, int *PL_UNUSED(skip_driver_bop)): plframe.c

process_data

process_data(Tcl_Interp *interp, register PlFrame *plFramePtr): plframe.c process_data(Tcl_Interp *interp, register PlPlotter *plPlotterPtr): plplotter.c

process_eop

process_eop(void *, int *): plframe.c process_eop(void *clientData, int *PL_UNUSED(skip_driver_eop)): plframe.c

ProcessOptplargs.c

PrompttkMain.c

prPromptCmdpltcl.c

ps_dispatch_init_helperps.c

ps_getdate

ps_getdate(void): ps.c ps_getdate(void): psttf.cc

ps_init

ps_init(PLStream *): ps.c ps_init(PLStream *): psttf.cc

psttf_dispatch_init_helperpsttf.cc

pstyplstream

ptexplstream

ptex3plstream

PyBool_FromLongplplotcPYTHON_wrap.c

PyModule_AddObjectplplotcPYTHON_wrap.c

PyNumber_AsSsize_tplplotcPYTHON_wrap.c

PyString_FromFormatplplotcPYTHON_wrap.c