=head1 NAME

B<Lua Dislin> - Lua wrapper for the DISLIN plotting & widgets 
library (ldislin)

=head1 OVERVIEW

B<Lua Dislin> provides a Lua interface for the DISLIN plotting & 
widgets library available from the Max Planck Institute for Solar 
System Research: L<http://www.dislin.de/>

B<Lua Dislin> has examples & over 500 functions for scientific 
plots, business graphs, and widget based GUIs.

DISLIN is free for non-commercial use. 
See the DISLIN site for details.

This version of B<Lua Dislin> was developed and tested with 
DISLIN 9.1.

=head1 DOWNLOAD

B<Lua Dislin> wrapper source code can be downloaded from its 
LuaForge (L<http://luaforge.net/projects/ldislin/files>) page.

=head1 INSTALLATION

A I<Makefile> is provided. You will need to obtain DISLIN from its 
site L<http://www.dislin.de/>, and modify the Makefile to indicate
where it is installed on your system.

The file I<processh.lua> is included, and was used to generate much
of the C source code for the wrapper. For a new version of DISLIN 
you may wish to run I<processh.lua> again, and merge the generated
code into I<ldislin.c>.

=head1 USAGE

There are several examples in the I<examples> directory.

It is instructive to compare these examples to the Python examples
from the DISLIN site at L<http://www.dislin.de/>.

Here is a complete program to create a bar chart:

    require "ldislin"
    dislin.metafl "XWIN"
    dislin.disini ()
    dislin.qplbar ({0.5,1,2,4,8,16,8,4,2,1,0.5}, 11)

Note that B<Lua Dislin> may only be used in a single threaded manner.
This is a limitation of DISLIN in the context of Lua coroutines.
The functions L<C<dislin.thrini>|/dislin.thrini> and 
L<C<dislin.thrfin>|/dislin.thrfin> may be used to support
multiple Lua interpreters in separate OS threads using B<Lua Dislin>
simultaneously, but this has not be tested.

=head1 REFERENCE

All of the functions provided are thin wrappers over the DISLIN functions.
Characters and strings are provided to and returned from the library functions
as Lua strings, integers and floats as Lua numbers, arrays and matrices as
Lua tables, and functions as Lua functions.

Only a few things complicate matters:

=over 4

=item * 

Functions that return values using C reference arguments

=item * 

Functions that return (out, or in/out) arrays

=item * 

Functions that modify strings

=item * 

Functions that take function arguments

=back

In general, B<Lua Dislin> returns values in this order: the value returned
by the function, if any, followed by any values returned by reference in the
order of the corresponding C reference arguments. If a C reference argument
is in/out, then the value must be supplied by the caller of the Lua wrapper.
Otherwise, the library will construct a table to return the result array.

Note that functions that take in/out array parameters always return new 
tables, and never modify their table arguments.

The function reference is divided into sections for:

=over 4

=item *

Functions With Special Handling

=item *

Functions Returning Multiple Scalars

=item *

Functions With No Special Handling

=back

The documentation for the Functions With No Special Handling is 
generated from the DISLIN C header file directly. Please refer to the
DISLIN documentation at L<http://www.dislin.de/> for a complete 
description of the functions' operation.

=head1 Functions With Special Handling

=head2 C<legend_buffer>

There is one userdata type created and used by B<Lua Dislin>; this is 
the  C<legend_buffer>. A C<legend_buffer> is created with 
L<C<dislin.legini>|/dislin.legini> and used by 
L<C<dislin.piegrf>|/dislin.piegrf>
L<C<dislin.legend>|/dislin.legend>
L<C<dislin.leglin>|/dislin.leglin>
L<C<dislin.nxlegn>|/dislin.nxlegn> and
L<C<dislin.nylegn>|/dislin.nylegn>

When translating DISLIN examples from other languages such as Python, 
typically you would replace sequences such as:

    cbuf = '         '
    dislin.legini (cbuf, n, w)

with

    cbuf = dislin.legini (n, w)

and then use C<cbuf> as the modifiable string buffer argument to the 
functions using this C<legend_buffer>.

=head2 C<dislin.bars>

  dislin.bars (xray, y1ray, y2ray, n [, ret])

Normally there are no return values from C<dislin.bars>. However, bars can return 
values calculated by DISLIN if a special option is set with C<dislin.barpos>. So, 
the optional argument C<ret>, if true, will cause the calculated arrays, 
C<xray>, C<y1ray>, C<y2ray> to be returned from C<dislin.bars>.

=head2 C<dislin.bezier>

  dislin.bezier (xray, yray, n, np)

Returns arrays C<xpray> and C<ypray>.

=head2 C<dislin.colray>

  dislin.colray (zray, n)

Returns integer array C<nray>.

=head2 C<dislin.conpts>

  dislin.conpts (xray, n, yray, m, zmat, zlev, maxpts, maxray)

Returns C<xpts>, C<ypts>, C<nray>.

=head2 C<dislin.getlab>

  dislin.getlab ()

Returns three strings, C<cx>, C<cy>, C<cz>.

=head2 C<dislin.getmat>

  dislin.getmat (xray, yray, zray, n, nx, ny, zval [, ret])

Returns C<zmat>. If C<ret> is true, also returns C<imat>.

=head2 C<dislin.gwgfil>

  dislin.gwgfil (id)

Returns C<cfile>.

=head2 C<dislin.gwgtxt>

  dislin.gwgtxt (id)

Returns C<ctext>.

=head2 C<dislin.histog>

  dislin.histog (xray, n)

Returns C<xhray>, C<yhray>, and C<m>.

=head2 C<dislin.legend>

  dislin.legend (cbuf, ncor)
  cbuf:legend (ncor)

Note that the cbuf argument is a L<C<legend_buffer>|/legend_buffer>.

=head2 C<dislin.legini>

  dislin.legini (nlin, nmaxln)

Returns a newly created  L<C<legend_buffer>|/legend_buffer> C<cbuf>.

=head2 C<dislin.leglin>

  dislin.leglin (cbuf, cstr, ilin)
  cbuf:leglin (cstr, ilin)

Note that the cbuf argument is a L<C<legend_buffer>|/legend_buffer>.

=head2 C<dislin.nxlegn>

  dislin.nxlegn (cbuf)
  cbuf:nxlegn ()

Returns integer C<nxlegn>.

Note that the cbuf argument is a L<C<legend_buffer>|/legend_buffer>.

=head2 C<dislin.nylegn>

  dislin.nylegn (cbuf)
  cbuf:nylegn ()

Returns integer C<nylegn>.

Note that the cbuf argument is a L<C<legend_buffer>|/legend_buffer>.

=head2 C<dislin.pdfbuf>

  dislin.pdfbuf (nmax)

Returns string C<cbuf> and integer C<n> the actual buffer size. If C<cbuf>
is C<nil> then C<n> is the required size > C<nmax>.

=head2 C<dislin.piegrf>

  dislin.piegrf (cbuf, nlin, xray, nseg)
  cbuf:piegrf (nlin, xray, nseg)

Note that the cbuf argument is a L<C<legend_buffer>|/legend_buffer>.

=head2 C<dislin.rbfpng>

  dislin.rbfpng (nmax)

Returns string C<cbuf> and integer C<n> the actual buffer size. If C<cbuf>
is C<nil> then C<n> is the required size > C<nmax>.

=head2 C<dislin.setcbk>

  dislin.setcbk (fun, copt)

Note that C<fun> is a Lua function.

=head2 C<dislin.sortr1>

  dislin.sortr1 (xray, n, copt)

Returns C<xray> (truncated to length C<n>) sorted as specified.

=head2 C<dislin.sortr2>

  dislin.sortr2 (xray, yray, n, copt)

Returns C<xray> and C<yray> (both truncated to length C<n>) sorted as specified.

=head2 C<dislin.spline>

  dislin.spline (xray, yray, n)

Returns C<xsray> and C<ysray>.

=head2 C<dislin.surfcp>

  dislin.surfcp (fun, amin, amax, astp, bmin, bmax, bstp)

Note that C<fun> is a Lua function.

=head2 C<dislin.surfun>

  dislin.surfun (fun, ixpts, xdel, iypts, ydel)

Note that C<fun> is a Lua function.

=head2 C<dislin.swgcbk>

  dislin.swgcbk (id, fun)

Note that C<fun> is a Lua function.

=head2 C<dislin.trfco1>

  dislin.trfco1 (xray, n, cfrom, cto)

Returns C<xray> (truncated to length C<n>) converted as specified.

=head2 C<dislin.trfco2>

  dislin.trfco2 (xray, yray, n, cfrom, cto)

Returns C<xray> and C<yray> (both truncated to length C<n>) converted 
as specified.

=head2 C<dislin.trfco3>

  dislin.trfco3 (xray, yray, zray, n, cfrom, cto)

Returns C<xray> C<yray> and C<aray> (all truncated to length C<n>) 
converted  as specified.

=head2 C<dislin.trfmat>

  dislin.trfmat (zmat, nx, ny, nx2, ny2)

Returns C<zmat> converted by bilinear interpolation.

=head2 C<dislin.trfrel>

  dislin.trfrel (xray, yray, n)

Returns C<xray> and C<yray> (both truncated to length C<n>) converted 
to plot coordinates.

=head2 C<dislin.triang>

  dislin.triang (xray, yray, n)

Returns C<i1ray>, C<i2ray>, C<i3ray>, and integer C<ntri>, the number 
of triangles.

=head2 C<dislin.tripts>

  dislin.tripts (xray, yray, zray, n, i1ray, i2ray, i3ray, ntri, zlev, maxpts, maxray)

Returns C<xpts>, C<ypts>, C<nptray>.

=head2 C<dislin.unit>

  dislin.unit (zero)

The argument to C<dislin.unit> must be zero; this function is provided for
(literal translation of) legacy code where C<dislin.unit (0)> is used as an 
idiom to suppress error messages. New code should use the newer routines 
L<C<dislin.errmod>|/dislin.errmod>
L<C<dislin.errdev>|/dislin.errdev> and 
L<C<dislin.errfil>|/dislin.errfil>

=head1 Functions Returning Multiple Scalars

=head2 C<dislin.abs3pt>

  dislin.abs3pt (x, y, z)

Returns the absolute 3-D argument point converted to plot coordinates, C<xp>, C<yp>.

=head2 C<dislin.circ3p>

  dislin.circ3p (x1, y1, x2, y2, x3, y3)

Calculates a circle specified by three points.

Returns C<xm>, C<ym>, C<r> which are the location of the center of the circle and the circle's radius.

=head2 C<dislin.csrpt1>

  dislin.csrpt1 ()

Returns C<nx>, C<ny>, the position of the cursor when the mouse button 1 is pressed.

=head2 C<dislin.getclp>

  dislin.getclp ()

Returns the upper left corner and the size of the current clipping window, C<nx>, C<ny>, C<nw>, C<nh>.
See L<C<dislin.clpwin>|/dislin.clpwin>.

=head2 C<dislin.getdig>

  dislin.getdig ()

Returns the number of decimal places that are displayed in axis labels, C<nxdig>, C<nydig>, C<nzdig>.
See L<C<dislin.labdig>|/dislin.labdig>.

=head2 C<dislin.getgrf>

  dislin.getgrf (cax)

Returns the current scaling of an axis system for axis C<cax>, 'X', 'Y', or 'Z'. The returned values
are C<xa>, C<xe>, C<xor>, C<xstp>, which are the lower and upper limits of the axis, the first axis
label, and the step between labels.

=head2 C<dislin.getlen>

  dislin.getlen ()

Returns the length of the X-, Y- and Z-axes, C<nxl>, C<nyl>, C<nzl>.
See L<C<dislin.axslen>|/dislin.axslen>, L<C<dislin.axlen>|/dislin.axlen>.

=head2 C<dislin.getor>

  dislin.getor ()

Returns the coordinates of the origin, C<nx0>, C<ny0>.
See L<C<dislin.origin>|/dislin.origin>.

=head2 C<dislin.getpag>

  dislin.getpag ()

Returns the page size, C<nxpag>, C<nypag>.
See L<C<dislin.setpag>|/dislin.setpag>,  L<C<dislin.page>|/dislin.page>.

=head2 C<dislin.getpos>

  dislin.getpos ()

Returns the position of the lower left corner of an axis system in plot coordinates, C<nxa>, C<nya>.
See L<C<dislin.axspos>|/dislin.axspos>.

=head2 C<dislin.getran>

  dislin.getran ()

Returns the color range of color bars, C<nca>, C<nce>.
See L<C<dislin.colran>|/dislin.colran>.

=head2 C<dislin.getres>

  dislin.getres ()

Returns the width and height of rectangles plotted in 3-D colour graphics, C<npb>, C<nph>.
See L<C<dislin.setres>|/dislin.setres>, L<C<dislin.autres>|/dislin.autres>.

=head2 C<dislin.getrgb>

  dislin.getrgb ()

Returns the RGB coordinates of the current color, C<xr>, C<xg>, C<xb>.

=head2 C<dislin.getscl>

  dislin.getscl ()

Returns the type of axis scaling used for each axis: C<nxlog>, C<<nylog>, C<<nzlog>. For
linear scaling, the value 0 is returned and for logarithmic scaling, the value 1 is returned.
See L<C<dislin.axsscl>|/dislin.axsscl>.

=head2 C<dislin.getscr>

  dislin.getscr ()

Returns the width and height of the screen in pixels, C<nwpix>, C<nhpix>.

=head2 C<dislin.getsp1>

  dislin.getsp1 ()

Returns the distance between axis ticks and labels, C<nxdis>, C<nydis>, C<nzdis>.
See L<C<dislin.labdis>|/dislin.labdis>.

=head2 C<dislin.getsp2>

  dislin.getsp2 ()

Returns the distance between axis labels and names, C<nxdis>, C<nydis>, C<nzdis>.
See L<C<dislin.namdis>|/dislin.namdis>.

=head2 C<dislin.getsym>

  dislin.getsym ()

Returns the current symbol number and height of symbols, C<nsym>, C<nhsymb>.

=head2 C<dislin.gettcl>

  dislin.gettcl ()

Returns tick lengths, C<nmaj>, C<nmin>.

=head2 C<dislin.gettic>

  dislin.gettic ()

Returns the number of ticks that are plotted between axis labels, C<nxtic>, C<nytic>, C<nztic>.
See L<C<dislin.ticks>|/dislin.ticks>.

=head2 C<dislin.getvk>

  dislin.getvk ()

Returns the lengths used for shifting titles and color bars, C<nytit>, C<nxbar>, C<nybar>.
See L<C<dislin.vkytit>|/dislin.vkytit>, L<C<dislin.vkxbar>|/dislin.vkxbar>, L<C<dislin.vkybar>|/dislin.vkybar>.

=head2 C<dislin.getwin>

  dislin.getwin ()

Returns the upper left corner and the size of the graphics window, C<nx>, C<ny>, C<nw>, C<nh>.
See L<C<dislin.window>|/dislin.window>, L<C<dislin.winsiz>|/dislin.winsiz>.

=head2 C<dislin.gmxalf>

  dislin.gmxalf (calph)

Returns shift characters used for shifting between the base and an alternate alphabet for the
alphabet C<calph>: C<n>, C<c1>, C<c2>, where C<n> is the returned index of the alphabet between
0 and 6. If C<n = 0>, no shift characters are defined for the alphabet C<calph>. C<c1> and C<c2>
are character strings that contain the returned shift characters.
See L<C<dislin.smxalf>|/dislin.smxalf>.

=head2 C<dislin.hsvrgb>

  dislin.hsvrgb (xh, xs, xv)

Returns C<xr>, C<xg>, C<xb>, RGB values in the range 0 to 1 corresponding to the HSV argument.

=head2 C<dislin.pos2pt>

  dislin.pos2pt (xlong, ylat)

Returns plot coordinates C<xp>, C<yp>, corresponding to map (longitude and latitude) coordinate argument.

=head2 C<dislin.pos3pt>

  dislin.pos3pt (x, y, z)

Returns the absolute 3-D coordinates, C<xp>, C<yp>, C<zp>, converted from user coordinates.

=head2 C<dislin.rel3pt>

  dislin.rel3pt (x, y, z)

Returns the plot coordinates, C<xp>, C<yp>, converted from user coordinates.

=head2 C<dislin.rgbhsv>

  dislin.rgbhsv (xr, xg, xb)

Returns C<xh>, C<xs>, C<xv>, HSV values corresponding to the RGB argument.

=head2 C<dislin.rpixel>

  dislin.rpixel (ix, iy)

Returns the value of one pixel C<iclr> from memory at the specified position in screen coordinates.
C<iclr> is the returned color value of the pixel. If the parameter ’RGB’ had been used with the
routine dislin.imgmod, C<iclr> is an explicit RGB value, otherwise an entry of the color table.

=head2 C<dislin.trfdat>

  dislin.trfdat (n)

Returns the date, C<iday>, C<imonth>, C<iyear>, occuring C<n> days after the base date.
See L<C<dislin.basdat>|/dislin.basdat>.

=head1 Functions With No Special Handling

=head2 C<dislin.addlab>

  dislin.addlab (cstr, v, itic, cax)

=head2 C<dislin.angle>

  dislin.angle (ngrad)

=head2 C<dislin.arcell>

  dislin.arcell (nx, ny, na, nb, a, b, t)

=head2 C<dislin.areaf>

  dislin.areaf (nxray, nyray, n)

=head2 C<dislin.autres>

  dislin.autres (ixdim, iydim)

=head2 C<dislin.ax2grf>

  dislin.ax2grf ()

=head2 C<dislin.ax3len>

  dislin.ax3len (nxl, nyl, nzl)

=head2 C<dislin.axclrs>

  dislin.axclrs (nclr, copt, cax)

=head2 C<dislin.axends>

  dislin.axends (cstr, cax)

=head2 C<dislin.axgit>

  dislin.axgit ()

=head2 C<dislin.axis3d>

  dislin.axis3d (x3, y3, z3)

=head2 C<dislin.axsbgd>

  dislin.axsbgd (nclr)

=head2 C<dislin.axslen>

  dislin.axslen (nxl, nyl)

=head2 C<dislin.axsorg>

  dislin.axsorg (nxa, nya)

=head2 C<dislin.axspos>

  dislin.axspos (nxa, nya)

=head2 C<dislin.axsscl>

  dislin.axsscl (cscl, cax)

=head2 C<dislin.axstyp>

  dislin.axstyp (copt)

=head2 C<dislin.barbor>

  dislin.barbor (iclr)

=head2 C<dislin.barclr>

  dislin.barclr (ic1, ic2, ic3)

=head2 C<dislin.bargrp>

  dislin.bargrp (ngrp, gap)

=head2 C<dislin.barmod>

  dislin.barmod (cmod, copt)

=head2 C<dislin.baropt>

  dislin.baropt (xf, a)

=head2 C<dislin.barpos>

  dislin.barpos (copt)

=head2 C<dislin.bars3d>

  dislin.bars3d (xray, yray, z1ray, z2ray, xwray, ywray, icray, n)

=head2 C<dislin.bartyp>

  dislin.bartyp (ctyp)

=head2 C<dislin.barwth>

  dislin.barwth (factor)

=head2 C<dislin.basalf>

  dislin.basalf (calph)

=head2 C<dislin.basdat>

  dislin.basdat (id, im, iy)

=head2 C<dislin.bitsi2>

  dislin.bitsi2 (nbits, mher, iher, mhin, ihin)

Returns integer C<bitsi2>.

=head2 C<dislin.bitsi4>

  dislin.bitsi4 (nbits, mher, iher, mhin, ihin)

Returns integer C<bitsi4>.

=head2 C<dislin.bmpfnt>

  dislin.bmpfnt (copt)

=head2 C<dislin.box2d>

  dislin.box2d ()

=head2 C<dislin.box3d>

  dislin.box3d ()

=head2 C<dislin.center>

  dislin.center ()

=head2 C<dislin.cgmbgd>

  dislin.cgmbgd (xr, xg, xb)

=head2 C<dislin.cgmpic>

  dislin.cgmpic (cstr)

=head2 C<dislin.cgmver>

  dislin.cgmver (nclr)

=head2 C<dislin.chaang>

  dislin.chaang (angle)

=head2 C<dislin.chacod>

  dislin.chacod (copt)

=head2 C<dislin.chaspc>

  dislin.chaspc (xspc)

=head2 C<dislin.chawth>

  dislin.chawth (xwth)

=head2 C<dislin.chnatt>

  dislin.chnatt ()

=head2 C<dislin.chnbar>

  dislin.chnbar (copt)

=head2 C<dislin.chncrv>

  dislin.chncrv (copt)

=head2 C<dislin.chndot>

  dislin.chndot ()

=head2 C<dislin.chndsh>

  dislin.chndsh ()

=head2 C<dislin.chnpie>

  dislin.chnpie (copt)

=head2 C<dislin.circle>

  dislin.circle (nx, ny, nr)

=head2 C<dislin.circsp>

  dislin.circsp (nspc)

=head2 C<dislin.clip3d>

  dislin.clip3d (ctyp)

=head2 C<dislin.clpbor>

  dislin.clpbor (copt)

=head2 C<dislin.clpmod>

  dislin.clpmod (copt)

=head2 C<dislin.clpwin>

  dislin.clpwin (nx, ny, nw, nh)

=head2 C<dislin.clrcyc>

  dislin.clrcyc (index, iclr)

=head2 C<dislin.clrmod>

  dislin.clrmod (cmode)

=head2 C<dislin.clswin>

  dislin.clswin (id)

=head2 C<dislin.color>

  dislin.color (col)

=head2 C<dislin.colran>

  dislin.colran (nca, nce)

=head2 C<dislin.complx>

  dislin.complx ()

=head2 C<dislin.conclr>

  dislin.conclr (nray, n)

=head2 C<dislin.concrv>

  dislin.concrv (xray, yray, n, zlev)

=head2 C<dislin.confll>

  dislin.confll (xray, yray, zray, n, i1ray, i2ray, i3ray, ntri, zlev, nlev)

=head2 C<dislin.congap>

  dislin.congap (xfac)

=head2 C<dislin.conlab>

  dislin.conlab (clab)

=head2 C<dislin.conmat>

  dislin.conmat (zmat, n, m, zlev)

=head2 C<dislin.conmod>

  dislin.conmod (xfac, xquot)

=head2 C<dislin.conn3d>

  dislin.conn3d (x, y, z)

=head2 C<dislin.connpt>

  dislin.connpt (x, y)

=head2 C<dislin.conshd>

  dislin.conshd (xray, n, yray, m, zmat, zlev, nlev)

=head2 C<dislin.contri>

  dislin.contri (xray, yray, zray, n, i1ray, i2ray, i3ray, ntri, zlev)

=head2 C<dislin.contur>

  dislin.contur (xray, n, yray, m, zmat, zlev)

=head2 C<dislin.cross>

  dislin.cross ()

=head2 C<dislin.crvmat>

  dislin.crvmat (zmat, n, m, ixpts, iypts)

=head2 C<dislin.crvtri>

  dislin.crvtri (xray, yray, zray, n, i1ray, i2ray, i3ray, ntri)

=head2 C<dislin.csrmod>

  dislin.csrmod (cmod, ckey)

=head2 C<dislin.csrtyp>

  dislin.csrtyp (copt)

=head2 C<dislin.csruni>

  dislin.csruni (copt)

=head2 C<dislin.curv3d>

  dislin.curv3d (xray, yray, zray, n)

=head2 C<dislin.curve>

  dislin.curve (xray, yray, n)

=head2 C<dislin.curve3>

  dislin.curve3 (xray, yray, zray, n)

=head2 C<dislin.curvmp>

  dislin.curvmp (xray, yray, n)

=head2 C<dislin.curvx3>

  dislin.curvx3 (xray, y, zray, n)

=head2 C<dislin.curvy3>

  dislin.curvy3 (x, yray, zray, n)

=head2 C<dislin.dash>

  dislin.dash ()

=head2 C<dislin.dashl>

  dislin.dashl ()

=head2 C<dislin.dashm>

  dislin.dashm ()

=head2 C<dislin.delglb>

  dislin.delglb ()

=head2 C<dislin.disalf>

  dislin.disalf ()

=head2 C<dislin.disfin>

  dislin.disfin ()

=head2 C<dislin.disini>

  dislin.disini ()

=head2 C<dislin.dot>

  dislin.dot ()

=head2 C<dislin.dotl>

  dislin.dotl ()

=head2 C<dislin.duplx>

  dislin.duplx ()

=head2 C<dislin.dwgbut>

  dislin.dwgbut (cstr, ival)

Returns integer C<dwgbut>.

=head2 C<dislin.dwgfil>

  dislin.dwgfil (clab, cstr, cmask)

Returns string C<dwgfil>.

=head2 C<dislin.dwglis>

  dislin.dwglis (clab, clis, ilis)

Returns integer C<dwglis>.

=head2 C<dislin.dwgmsg>

  dislin.dwgmsg (cstr)

=head2 C<dislin.dwgtxt>

  dislin.dwgtxt (clab, cstr)

Returns string C<dwgtxt>.

=head2 C<dislin.ellips>

  dislin.ellips (nx, ny, na, nb)

=head2 C<dislin.endgrf>

  dislin.endgrf ()

=head2 C<dislin.erase>

  dislin.erase ()

=head2 C<dislin.errbar>

  dislin.errbar (x, y, err1, err2, n)

=head2 C<dislin.errdev>

  dislin.errdev (cdev)

=head2 C<dislin.errfil>

  dislin.errfil (cfil)

=head2 C<dislin.errmod>

  dislin.errmod (cstr, copt)

=head2 C<dislin.eushft>

  dislin.eushft (cnat, cshf)

=head2 C<dislin.expzlb>

  dislin.expzlb (cstr)

=head2 C<dislin.field>

  dislin.field (xray, yray, uray, vray, n, ivec)

=head2 C<dislin.filbox>

  dislin.filbox (nx, ny, nw, nh)

=head2 C<dislin.filclr>

  dislin.filclr (copt)

=head2 C<dislin.filmod>

  dislin.filmod (cmod)

=head2 C<dislin.fixspc>

  dislin.fixspc (xfac)

=head2 C<dislin.flab3d>

  dislin.flab3d ()

=head2 C<dislin.flen>

  dislin.flen (x, ndig)

Returns integer C<flen>.

=head2 C<dislin.frame>

  dislin.frame (nfrm)

=head2 C<dislin.frmclr>

  dislin.frmclr (nclr)

=head2 C<dislin.frmess>

  dislin.frmess (nfrm)

=head2 C<dislin.gapcrv>

  dislin.gapcrv (xgap)

=head2 C<dislin.getalf>

  dislin.getalf ()

Returns string C<getalf>.

=head2 C<dislin.getang>

  dislin.getang ()

Returns integer C<getang>.

=head2 C<dislin.getbpp>

  dislin.getbpp ()

Returns integer C<getbpp>.

=head2 C<dislin.getclr>

  dislin.getclr ()

Returns integer C<getclr>.

=head2 C<dislin.getdsp>

  dislin.getdsp ()

Returns string C<getdsp>.

=head2 C<dislin.getfil>

  dislin.getfil ()

Returns string C<getfil>.

=head2 C<dislin.gethgt>

  dislin.gethgt ()

Returns integer C<gethgt>.

=head2 C<dislin.gethnm>

  dislin.gethnm ()

Returns integer C<gethnm>.

=head2 C<dislin.getlev>

  dislin.getlev ()

Returns integer C<getlev>.

=head2 C<dislin.getlin>

  dislin.getlin ()

Returns integer C<getlin>.

=head2 C<dislin.getlit>

  dislin.getlit (xp, yp, zp, xn, yn, zn)

Returns integer C<getlit>.

=head2 C<dislin.getmfl>

  dislin.getmfl ()

Returns string C<getmfl>.

=head2 C<dislin.getmix>

  dislin.getmix (copt)

Returns string C<getmix>.

=head2 C<dislin.getpat>

  dislin.getpat ()

Returns integer C<getpat>.

=head2 C<dislin.getplv>

  dislin.getplv ()

Returns integer C<getplv>.

=head2 C<dislin.getshf>

  dislin.getshf (copt)

Returns string C<getshf>.

=head2 C<dislin.gettyp>

  dislin.gettyp ()

Returns integer C<gettyp>.

=head2 C<dislin.getver>

  dislin.getver ()

Returns number C<getver>.

=head2 C<dislin.getvlt>

  dislin.getvlt ()

Returns string C<getvlt>.

=head2 C<dislin.getwid>

  dislin.getwid ()

Returns integer C<getwid>.

=head2 C<dislin.getxid>

  dislin.getxid (copt)

Returns integer C<getxid>.

=head2 C<dislin.gifmod>

  dislin.gifmod (cmod, ckey)

=head2 C<dislin.gothic>

  dislin.gothic ()

=head2 C<dislin.grace>

  dislin.grace (ngrace)

=head2 C<dislin.graf>

  dislin.graf (xa, xe, xorg, xstp, ya, ye, yorg, ystp)

=head2 C<dislin.graf3>

  dislin.graf3 (xa, xe, xorg, xstp, ya, ye, yorg, ystp, za, ze, zorg, zstp)

=head2 C<dislin.graf3d>

  dislin.graf3d (xa, xe, xorg, xstp, ya, ye, yorg, ystp, za, ze, zorg, zstp)

=head2 C<dislin.grafmp>

  dislin.grafmp (xa, xe, xorg, xstp, ya, ye, yorg, ystp)

=head2 C<dislin.grdpol>

  dislin.grdpol (ixgrid, iygrid)

=head2 C<dislin.grffin>

  dislin.grffin ()

=head2 C<dislin.grfini>

  dislin.grfini (x1, y1, z1, x2, y2, z2, x3, y3, z3)

=head2 C<dislin.grid>

  dislin.grid (ixgrid, iygrid)

=head2 C<dislin.grid3d>

  dislin.grid3d (ixgrid, iygrid, copt)

=head2 C<dislin.gridmp>

  dislin.gridmp (ixgrid, iygrid)

=head2 C<dislin.gwgatt>

  dislin.gwgatt (id, copt)

Returns integer C<gwgatt>.

=head2 C<dislin.gwgbox>

  dislin.gwgbox (id)

Returns integer C<gwgbox>.

=head2 C<dislin.gwgbut>

  dislin.gwgbut (id)

Returns integer C<gwgbut>.

=head2 C<dislin.gwglis>

  dislin.gwglis (id)

Returns integer C<gwglis>.

=head2 C<dislin.gwgscl>

  dislin.gwgscl (id)

Returns number C<gwgscl>.

=head2 C<dislin.gwgxid>

  dislin.gwgxid (id)

Returns integer C<gwgxid>.

=head2 C<dislin.height>

  dislin.height (nhchar)

=head2 C<dislin.helve>

  dislin.helve ()

=head2 C<dislin.helves>

  dislin.helves ()

=head2 C<dislin.hname>

  dislin.hname (nhchar)

=head2 C<dislin.hsymbl>

  dislin.hsymbl (nhsym)

=head2 C<dislin.htitle>

  dislin.htitle (nhtit)

=head2 C<dislin.hwfont>

  dislin.hwfont ()

=head2 C<dislin.hworig>

  dislin.hworig (nx, ny)

=head2 C<dislin.hwpage>

  dislin.hwpage (nw, nh)

=head2 C<dislin.imgbox>

  dislin.imgbox (nx, ny, nw, nh)

=head2 C<dislin.imgclp>

  dislin.imgclp (nx, ny, nw, nh)

=head2 C<dislin.imgfin>

  dislin.imgfin ()

=head2 C<dislin.imgfmt>

  dislin.imgfmt (copt)

=head2 C<dislin.imgini>

  dislin.imgini ()

=head2 C<dislin.imgmod>

  dislin.imgmod (copt)

=head2 C<dislin.imgsiz>

  dislin.imgsiz (nw, nh)

=head2 C<dislin.inccrv>

  dislin.inccrv (ncrv)

=head2 C<dislin.incdat>

  dislin.incdat (id, im, iy)

Returns integer C<incdat>.

=head2 C<dislin.incfil>

  dislin.incfil (cfil)

=head2 C<dislin.incmrk>

  dislin.incmrk (nmrk)

=head2 C<dislin.indrgb>

  dislin.indrgb (xr, xg, xb)

Returns integer C<indrgb>.

=head2 C<dislin.intax>

  dislin.intax ()

=head2 C<dislin.intlen>

  dislin.intlen (nx)

Returns integer C<intlen>.

=head2 C<dislin.intrgb>

  dislin.intrgb (xr, xg, xb)

Returns integer C<intrgb>.

=head2 C<dislin.itmcnt>

  dislin.itmcnt (clis)

Returns integer C<itmcnt>.

=head2 C<dislin.itmstr>

  dislin.itmstr (clis, nlis)

Returns string C<itmstr>.

=head2 C<dislin.labclr>

  dislin.labclr (iclr, copt)

=head2 C<dislin.labdig>

  dislin.labdig (ndig, cax)

=head2 C<dislin.labdis>

  dislin.labdis (ndis, cax)

=head2 C<dislin.labels>

  dislin.labels (clab, cax)

=head2 C<dislin.labjus>

  dislin.labjus (copt, cax)

=head2 C<dislin.labl3d>

  dislin.labl3d (copt)

=head2 C<dislin.labmod>

  dislin.labmod (ckey, cval, cax)

=head2 C<dislin.labpos>

  dislin.labpos (cpos, cax)

=head2 C<dislin.labtyp>

  dislin.labtyp (ctyp, cax)

=head2 C<dislin.legclr>

  dislin.legclr ()

=head2 C<dislin.legopt>

  dislin.legopt (x1, x2, x3)

=head2 C<dislin.legpat>

  dislin.legpat (ityp, ithk, isym, iclr, ipat, ilin)

=head2 C<dislin.legpos>

  dislin.legpos (nx, ny)

=head2 C<dislin.legtit>

  dislin.legtit (cstr)

=head2 C<dislin.lfttit>

  dislin.lfttit ()

=head2 C<dislin.light>

  dislin.light (copt)

=head2 C<dislin.lincyc>

  dislin.lincyc (index, ityp)

=head2 C<dislin.line>

  dislin.line (nx, ny, nu, nv)

=head2 C<dislin.linesp>

  dislin.linesp (xfac)

=head2 C<dislin.lintyp>

  dislin.lintyp (ntyp)

=head2 C<dislin.linwid>

  dislin.linwid (i)

=head2 C<dislin.litmod>

  dislin.litmod (id, copt)

=head2 C<dislin.litop3>

  dislin.litop3 (id, xr, xg, xb, copt)

=head2 C<dislin.litopt>

  dislin.litopt (id, xval, copt)

=head2 C<dislin.litpos>

  dislin.litpos (id, x, y, z, copt)

=head2 C<dislin.lncap>

  dislin.lncap (copt)

=head2 C<dislin.lnjoin>

  dislin.lnjoin (copt)

=head2 C<dislin.lnmlt>

  dislin.lnmlt (x)

=head2 C<dislin.logtic>

  dislin.logtic (cmod)

=head2 C<dislin.mapbas>

  dislin.mapbas (cmod)

=head2 C<dislin.mapfil>

  dislin.mapfil (cfil, copt)

=head2 C<dislin.maplev>

  dislin.maplev (cmod)

=head2 C<dislin.mapmod>

  dislin.mapmod (cmod)

=head2 C<dislin.mappol>

  dislin.mappol (xpol, ypol)

=head2 C<dislin.mapref>

  dislin.mapref (ylower, yupper)

=head2 C<dislin.mapsph>

  dislin.mapsph (xrad)

=head2 C<dislin.marker>

  dislin.marker (nsym)

=head2 C<dislin.matop3>

  dislin.matop3 (xr, xg, xb, copt)

=head2 C<dislin.matopt>

  dislin.matopt (xval, copt)

=head2 C<dislin.mdfmat>

  dislin.mdfmat (nx, ny, weight)

=head2 C<dislin.messag>

  dislin.messag (cstr, nx, ny)

=head2 C<dislin.metafl>

  dislin.metafl (cstr)

=head2 C<dislin.mixalf>

  dislin.mixalf ()

=head2 C<dislin.mixleg>

  dislin.mixleg ()

=head2 C<dislin.mpaepl>

  dislin.mpaepl (i)

=head2 C<dislin.mplang>

  dislin.mplang (x)

=head2 C<dislin.mplclr>

  dislin.mplclr (nbg, nfg)

=head2 C<dislin.mplpos>

  dislin.mplpos (nx, ny)

=head2 C<dislin.mplsiz>

  dislin.mplsiz (nsize)

=head2 C<dislin.mpslogo>

  dislin.mpslogo (nx, ny, nsize, copt)

=head2 C<dislin.msgbox>

  dislin.msgbox (cstr)

=head2 C<dislin.mshclr>

  dislin.mshclr (ic)

=head2 C<dislin.mylab>

  dislin.mylab (cstr, itick, cax)

=head2 C<dislin.myline>

  dislin.myline (nray, n)

=head2 C<dislin.mypat>

  dislin.mypat (iang, itype, idens, icross)

=head2 C<dislin.mysymb>

  dislin.mysymb (xray, yray, n, isym, iflag)

=head2 C<dislin.myvlt>

  dislin.myvlt (xr, xg, xb, n)

=head2 C<dislin.namdis>

  dislin.namdis (ndis, cax)

=head2 C<dislin.name>

  dislin.name (cstr, cax)

=head2 C<dislin.namjus>

  dislin.namjus (copt, cax)

=head2 C<dislin.neglog>

  dislin.neglog (eps)

=head2 C<dislin.newmix>

  dislin.newmix ()

=head2 C<dislin.newpag>

  dislin.newpag ()

=head2 C<dislin.nlmess>

  dislin.nlmess (cstr)

Returns integer C<nlmess>.

=head2 C<dislin.nlnumb>

  dislin.nlnumb (x, ndig)

Returns integer C<nlnumb>.

=head2 C<dislin.noarln>

  dislin.noarln ()

=head2 C<dislin.nobar>

  dislin.nobar ()

=head2 C<dislin.nobgd>

  dislin.nobgd ()

=head2 C<dislin.nochek>

  dislin.nochek ()

=head2 C<dislin.noclip>

  dislin.noclip ()

=head2 C<dislin.nofill>

  dislin.nofill ()

=head2 C<dislin.nograf>

  dislin.nograf ()

=head2 C<dislin.nohide>

  dislin.nohide ()

=head2 C<dislin.noline>

  dislin.noline (cax)

=head2 C<dislin.number>

  dislin.number (x, ndig, nx, ny)

=head2 C<dislin.numfmt>

  dislin.numfmt (copt)

=head2 C<dislin.numode>

  dislin.numode (cdec, cgrp, cpos, cfix)

=head2 C<dislin.nwkday>

  dislin.nwkday (id, im, iy)

Returns integer C<nwkday>.

=head2 C<dislin.nxposn>

  dislin.nxposn (x)

Returns integer C<nxposn>.

=head2 C<dislin.nyposn>

  dislin.nyposn (y)

Returns integer C<nyposn>.

=head2 C<dislin.nzposn>

  dislin.nzposn (z)

Returns integer C<nzposn>.

=head2 C<dislin.opnwin>

  dislin.opnwin (id)

=head2 C<dislin.origin>

  dislin.origin (nx0, ny0)

=head2 C<dislin.page>

  dislin.page (nw, nh)

=head2 C<dislin.pagera>

  dislin.pagera ()

=head2 C<dislin.pagfll>

  dislin.pagfll (nclr)

=head2 C<dislin.paghdr>

  dislin.paghdr (cstr1, cstr2, iopt, idir)

=head2 C<dislin.pagmod>

  dislin.pagmod (cmod)

=head2 C<dislin.pagorg>

  dislin.pagorg (cpos)

=head2 C<dislin.patcyc>

  dislin.patcyc (index, ipat)

=head2 C<dislin.pdfmod>

  dislin.pdfmod (cmod, ckey)

=head2 C<dislin.pdfmrk>

  dislin.pdfmrk (cstr, copt)

=head2 C<dislin.penwid>

  dislin.penwid (x)

=head2 C<dislin.pie>

  dislin.pie (nxm, nym, nr, a, b)

=head2 C<dislin.piebor>

  dislin.piebor (iclr)

=head2 C<dislin.pieclr>

  dislin.pieclr (ic1, ic2, n)

=head2 C<dislin.pieexp>

  dislin.pieexp ()

=head2 C<dislin.pielab>

  dislin.pielab (clab, cpos)

=head2 C<dislin.pieopt>

  dislin.pieopt (xf, a)

=head2 C<dislin.pietyp>

  dislin.pietyp (ctyp)

=head2 C<dislin.pievec>

  dislin.pievec (ivec, copt)

=head2 C<dislin.pngmod>

  dislin.pngmod (cmod, ckey)

=head2 C<dislin.point>

  dislin.point (nx, ny, nb, nh, ncol)

=head2 C<dislin.polar>

  dislin.polar (xe, xorg, xstp, yorg, ystp)

=head2 C<dislin.polcrv>

  dislin.polcrv (cpol)

=head2 C<dislin.polmod>

  dislin.polmod (cpos, cdir)

=head2 C<dislin.projct>

  dislin.projct (cproj)

=head2 C<dislin.psfont>

  dislin.psfont (cfont)

=head2 C<dislin.psmode>

  dislin.psmode (cmod)

=head2 C<dislin.qplbar>

  dislin.qplbar (yray, n)

=head2 C<dislin.qplclr>

  dislin.qplclr (zmat, n, m)

=head2 C<dislin.qplcon>

  dislin.qplcon (zmat, n, m, nlv)

=head2 C<dislin.qplot>

  dislin.qplot (xray, yray, n)

=head2 C<dislin.qplpie>

  dislin.qplpie (xray, n)

=head2 C<dislin.qplsca>

  dislin.qplsca (xray, yray, n)

=head2 C<dislin.qplsur>

  dislin.qplsur (zmat, n, m)

=head2 C<dislin.rbmp>

  dislin.rbmp (cfil)

=head2 C<dislin.reawgt>

  dislin.reawgt ()

=head2 C<dislin.recfll>

  dislin.recfll (nx, ny, nw, nh, ncol)

=head2 C<dislin.rectan>

  dislin.rectan (nx, ny, nw, nh)

=head2 C<dislin.resatt>

  dislin.resatt ()

=head2 C<dislin.reset>

  dislin.reset (cname)

=head2 C<dislin.revscr>

  dislin.revscr ()

=head2 C<dislin.rgif>

  dislin.rgif (cfil)

=head2 C<dislin.rgtlab>

  dislin.rgtlab ()

=head2 C<dislin.rimage>

  dislin.rimage (cfil)

=head2 C<dislin.rlarc>

  dislin.rlarc (xm, ym, xa, xb, a, b, t)

=head2 C<dislin.rlarea>

  dislin.rlarea (xray, yray, n)

=head2 C<dislin.rlcirc>

  dislin.rlcirc (xm, ym, r)

=head2 C<dislin.rlconn>

  dislin.rlconn (x, y)

=head2 C<dislin.rlell>

  dislin.rlell (xm, ym, a, b)

=head2 C<dislin.rline>

  dislin.rline (x, y, u, v)

=head2 C<dislin.rlmess>

  dislin.rlmess (cstr, x, y)

=head2 C<dislin.rlnumb>

  dislin.rlnumb (x, ndig, xp, yp)

=head2 C<dislin.rlpie>

  dislin.rlpie (xm, ym, r, a, b)

=head2 C<dislin.rlpoin>

  dislin.rlpoin (x, y, nb, nh, ncol)

=head2 C<dislin.rlrec>

  dislin.rlrec (x, y, xw, xh)

=head2 C<dislin.rlrnd>

  dislin.rlrnd (x, y, xb, xh, irnd)

=head2 C<dislin.rlsec>

  dislin.rlsec (xm, ym, r1, r2, a, b, ncol)

=head2 C<dislin.rlstrt>

  dislin.rlstrt (x, y)

=head2 C<dislin.rlsymb>

  dislin.rlsymb (nsym, x, y)

=head2 C<dislin.rlvec>

  dislin.rlvec (x1, y1, x2, y2, ivec)

=head2 C<dislin.rlwind>

  dislin.rlwind (xk, x, y, nwidth, a)

=head2 C<dislin.rndrec>

  dislin.rndrec (nx, ny, nb, nh, irnd)

=head2 C<dislin.rpng>

  dislin.rpng (cfil)

=head2 C<dislin.rppm>

  dislin.rppm (cfil)

=head2 C<dislin.rtiff>

  dislin.rtiff (cfil)

=head2 C<dislin.rvynam>

  dislin.rvynam ()

=head2 C<dislin.sclfac>

  dislin.sclfac (xfac)

=head2 C<dislin.sclmod>

  dislin.sclmod (cmode)

=head2 C<dislin.scrmod>

  dislin.scrmod (cmode)

=head2 C<dislin.sector>

  dislin.sector (nx, ny, nr1, nr2, a, b, ncol)

=head2 C<dislin.selwin>

  dislin.selwin (id)

=head2 C<dislin.sendbf>

  dislin.sendbf ()

=head2 C<dislin.sendmb>

  dislin.sendmb ()

=head2 C<dislin.sendok>

  dislin.sendok ()

=head2 C<dislin.serif>

  dislin.serif ()

=head2 C<dislin.setbas>

  dislin.setbas (xfac)

=head2 C<dislin.setclr>

  dislin.setclr (ncol)

=head2 C<dislin.setcsr>

  dislin.setcsr (copt)

=head2 C<dislin.setexp>

  dislin.setexp (fexp)

=head2 C<dislin.setfil>

  dislin.setfil (cfil)

=head2 C<dislin.setgrf>

  dislin.setgrf (c1, c2, c3, c4)

=head2 C<dislin.setind>

  dislin.setind (index, xr, xg, xb)

=head2 C<dislin.setmix>

  dislin.setmix (cstr, cmix)

=head2 C<dislin.setpag>

  dislin.setpag (cpag)

=head2 C<dislin.setres>

  dislin.setres (npb, nph)

=head2 C<dislin.setrgb>

  dislin.setrgb (xr, xg, xb)

=head2 C<dislin.setscl>

  dislin.setscl (xray, n, cax)

=head2 C<dislin.setvlt>

  dislin.setvlt (cvlt)

=head2 C<dislin.setxid>

  dislin.setxid (id, copt)

=head2 C<dislin.shdafr>

  dislin.shdafr (inray, ipray, icray, n)

=head2 C<dislin.shdcha>

  dislin.shdcha ()

=head2 C<dislin.shdcrv>

  dislin.shdcrv (x1ray, y1ray, n1, x2ray, y2ray, n2)

=head2 C<dislin.shdeur>

  dislin.shdeur (inray, ipray, icray, n)

=head2 C<dislin.shdmap>

  dislin.shdmap (cmap)

=head2 C<dislin.shdmod>

  dislin.shdmod (copt, ctyp)

=head2 C<dislin.shdpat>

  dislin.shdpat (ipat)

=head2 C<dislin.shdusa>

  dislin.shdusa (inray, ipray, icray, n)

=head2 C<dislin.shield>

  dislin.shield (carea, cmode)

=head2 C<dislin.shlcir>

  dislin.shlcir (nx, ny, nr)

=head2 C<dislin.shldel>

  dislin.shldel (id)

=head2 C<dislin.shlell>

  dislin.shlell (nx, ny, na, nb, t)

=head2 C<dislin.shlind>

  dislin.shlind ()

Returns integer C<shlind>.

=head2 C<dislin.shlpie>

  dislin.shlpie (nx, ny, nr, a, b)

=head2 C<dislin.shlpol>

  dislin.shlpol (nxray, nyray, n)

=head2 C<dislin.shlrct>

  dislin.shlrct (nx, ny, nw, nh, t)

=head2 C<dislin.shlrec>

  dislin.shlrec (nx, ny, nw, nh)

=head2 C<dislin.shlres>

  dislin.shlres (n)

=head2 C<dislin.shlsur>

  dislin.shlsur ()

=head2 C<dislin.shlvis>

  dislin.shlvis (id, cmode)

=head2 C<dislin.simplx>

  dislin.simplx ()

=head2 C<dislin.smxalf>

  dislin.smxalf (calph, c1, c2, n)

=head2 C<dislin.solid>

  dislin.solid ()

=head2 C<dislin.sphe3d>

  dislin.sphe3d (xm, ym, zm, r, n, m)

=head2 C<dislin.splmod>

  dislin.splmod (ngrad, npts)

=head2 C<dislin.strt3d>

  dislin.strt3d (x, y, z)

=head2 C<dislin.strtpt>

  dislin.strtpt (x, y)

=head2 C<dislin.surclr>

  dislin.surclr (ictop, icbot)

=head2 C<dislin.surfce>

  dislin.surfce (xray, n, yray, m, zmat)

=head2 C<dislin.suriso>

  dislin.suriso (xray, nx, yray, ny, zray, nz, wmat, wlev)

=head2 C<dislin.surmat>

  dislin.surmat (zmat, nx, ny, ixpts, iypts)

=head2 C<dislin.surmsh>

  dislin.surmsh (copt)

=head2 C<dislin.suropt>

  dislin.suropt (copt)

=head2 C<dislin.surshd>

  dislin.surshd (xray, n, yray, m, zmat)

=head2 C<dislin.sursze>

  dislin.sursze (xmin, xmax, ymin, ymax)

=head2 C<dislin.surtri>

  dislin.surtri (xray, yray, zray, n, i1ray, i2ray, i3ray, ntri)

=head2 C<dislin.survis>

  dislin.survis (cvis)

=head2 C<dislin.swgatt>

  dislin.swgatt (id, cval, copt)

=head2 C<dislin.swgbox>

  dislin.swgbox (ip, ival)

=head2 C<dislin.swgbut>

  dislin.swgbut (ip, ival)

=head2 C<dislin.swgclr>

  dislin.swgclr (xr, xg, xb, copt)

=head2 C<dislin.swgdrw>

  dislin.swgdrw (x)

=head2 C<dislin.swgfil>

  dislin.swgfil (ip, cval)

=head2 C<dislin.swgfnt>

  dislin.swgfnt (cfnt, n)

=head2 C<dislin.swgfoc>

  dislin.swgfoc (id)

=head2 C<dislin.swghlp>

  dislin.swghlp (cstr)

=head2 C<dislin.swgjus>

  dislin.swgjus (ctyp, cwidg)

=head2 C<dislin.swglis>

  dislin.swglis (ip, ival)

=head2 C<dislin.swgmix>

  dislin.swgmix (c, cstr)

=head2 C<dislin.swgmrg>

  dislin.swgmrg (ival, cstr)

=head2 C<dislin.swgoff>

  dislin.swgoff (nx, ny)

=head2 C<dislin.swgopt>

  dislin.swgopt (cval, copt)

=head2 C<dislin.swgpop>

  dislin.swgpop (copt)

=head2 C<dislin.swgpos>

  dislin.swgpos (nx, ny)

=head2 C<dislin.swgscl>

  dislin.swgscl (ip, xval)

=head2 C<dislin.swgsiz>

  dislin.swgsiz (nx, ny)

=head2 C<dislin.swgspc>

  dislin.swgspc (xw, xh)

=head2 C<dislin.swgstp>

  dislin.swgstp (step)

=head2 C<dislin.swgtit>

  dislin.swgtit (ctit)

=head2 C<dislin.swgtxt>

  dislin.swgtxt (ip, cval)

=head2 C<dislin.swgtyp>

  dislin.swgtyp (ctyp, cwidg)

=head2 C<dislin.swgwin>

  dislin.swgwin (nx, ny, nw, nh)

=head2 C<dislin.swgwth>

  dislin.swgwth (nchar)

=head2 C<dislin.symbol>

  dislin.symbol (nsym, nx, ny)

=head2 C<dislin.symfil>

  dislin.symfil (cdev, cstat)

=head2 C<dislin.symrot>

  dislin.symrot (angle)

=head2 C<dislin.texmod>

  dislin.texmod (copt)

=head2 C<dislin.texopt>

  dislin.texopt (copt, ctyp)

=head2 C<dislin.texval>

  dislin.texval (x, copt)

=head2 C<dislin.thkcrv>

  dislin.thkcrv (nthk)

=head2 C<dislin.thrfin>

  dislin.thrfin ()

=head2 C<dislin.thrini>

  dislin.thrini (n)

=head2 C<dislin.ticks>

  dislin.ticks (itick, cax)

=head2 C<dislin.ticlen>

  dislin.ticlen (nmaj, nmin)

=head2 C<dislin.ticmod>

  dislin.ticmod (copt, cax)

=head2 C<dislin.ticpos>

  dislin.ticpos (cpos, cax)

=head2 C<dislin.tifmod>

  dislin.tifmod (n, cval, copt)

=head2 C<dislin.tiforg>

  dislin.tiforg (nx, ny)

=head2 C<dislin.tifwin>

  dislin.tifwin (nx, ny, nw, nh)

=head2 C<dislin.timopt>

  dislin.timopt ()

=head2 C<dislin.titjus>

  dislin.titjus (copt)

=head2 C<dislin.title>

  dislin.title ()

=head2 C<dislin.titlin>

  dislin.titlin (cstr, n)

=head2 C<dislin.titpos>

  dislin.titpos (copt)

=head2 C<dislin.trfres>

  dislin.trfres ()

=head2 C<dislin.trfrot>

  dislin.trfrot (xang, nx, ny)

=head2 C<dislin.trfscl>

  dislin.trfscl (xscl, yscl)

=head2 C<dislin.trfshf>

  dislin.trfshf (nx, ny)

=head2 C<dislin.trifll>

  dislin.trifll (xray, yray)

=head2 C<dislin.triplx>

  dislin.triplx ()

=head2 C<dislin.trmlen>

  dislin.trmlen (cstr)

Returns integer C<trmlen>.

=head2 C<dislin.txtjus>

  dislin.txtjus (copt)

=head2 C<dislin.units>

  dislin.units (copt)

=head2 C<dislin.vang3d>

  dislin.vang3d (a)

=head2 C<dislin.vclp3d>

  dislin.vclp3d (x1, x2)

=head2 C<dislin.vector>

  dislin.vector (nx1, ny1, nx2, ny2, ivec)

=head2 C<dislin.vectr3>

  dislin.vectr3 (x1, y1, z1, x2, y2, z2, ivec)

=head2 C<dislin.vfoc3d>

  dislin.vfoc3d (x, y, z, cview)

=head2 C<dislin.view3d>

  dislin.view3d (xvu, yvu, zvu, cvu)

=head2 C<dislin.vkxbar>

  dislin.vkxbar (nvfx)

=head2 C<dislin.vkybar>

  dislin.vkybar (nvfy)

=head2 C<dislin.vkytit>

  dislin.vkytit (nvfy)

=head2 C<dislin.vltfil>

  dislin.vltfil (cfl, copt)

=head2 C<dislin.vup3d>

  dislin.vup3d (a)

=head2 C<dislin.wgapp>

  dislin.wgapp (ip, clab)

Returns integer C<wgapp>.

=head2 C<dislin.wgbas>

  dislin.wgbas (ip, ctyp)

Returns integer C<wgbas>.

=head2 C<dislin.wgbox>

  dislin.wgbox (ip, cstr, isel)

Returns integer C<wgbox>.

=head2 C<dislin.wgbut>

  dislin.wgbut (ip, cstr, ival)

Returns integer C<wgbut>.

=head2 C<dislin.wgcmd>

  dislin.wgcmd (ip, clab, cmd)

Returns integer C<wgcmd>.

=head2 C<dislin.wgdlis>

  dislin.wgdlis (ip, cstr, isel)

Returns integer C<wgdlis>.

=head2 C<dislin.wgdraw>

  dislin.wgdraw (ip)

Returns integer C<wgdraw>.

=head2 C<dislin.wgfil>

  dislin.wgfil (ip, clab, cstr, cmask)

Returns integer C<wgfil>.

=head2 C<dislin.wgfin>

  dislin.wgfin ()

=head2 C<dislin.wgini>

  dislin.wgini (ctyp)

Returns integer C<wgini>.

=head2 C<dislin.wglab>

  dislin.wglab (ip, cstr)

Returns integer C<wglab>.

=head2 C<dislin.wglis>

  dislin.wglis (ip, cstr, isel)

Returns integer C<wglis>.

=head2 C<dislin.wgltxt>

  dislin.wgltxt (ip, clab, ctext, iper)

Returns integer C<wgltxt>.

=head2 C<dislin.wgok>

  dislin.wgok (ip)

Returns integer C<wgok>.

=head2 C<dislin.wgpbut>

  dislin.wgpbut (ip, clab)

Returns integer C<wgpbut>.

=head2 C<dislin.wgpop>

  dislin.wgpop (ip, clab)

Returns integer C<wgpop>.

=head2 C<dislin.wgquit>

  dislin.wgquit (ip)

Returns integer C<wgquit>.

=head2 C<dislin.wgscl>

  dislin.wgscl (ip, cstr, x1, x2, xval, ndez)

Returns integer C<wgscl>.

=head2 C<dislin.wgstxt>

  dislin.wgstxt (ip, nsize, nmax)

Returns integer C<wgstxt>.

=head2 C<dislin.wgtxt>

  dislin.wgtxt (ip, cstr)

Returns integer C<wgtxt>.

=head2 C<dislin.widbar>

  dislin.widbar (nzb)

=head2 C<dislin.wimage>

  dislin.wimage (cfil)

=head2 C<dislin.winapp>

  dislin.winapp (copt)

=head2 C<dislin.windbr>

  dislin.windbr (xk, nx, ny, nwidth, a)

=head2 C<dislin.window>

  dislin.window (nx, ny, nw, nh)

=head2 C<dislin.winfin>

  dislin.winfin (iopt)

=head2 C<dislin.winfnt>

  dislin.winfnt (cfont)

=head2 C<dislin.winid>

  dislin.winid ()

Returns integer C<winid>.

=head2 C<dislin.winkey>

  dislin.winkey (copt)

=head2 C<dislin.winmod>

  dislin.winmod (copt)

=head2 C<dislin.winopt>

  dislin.winopt (iopt, copt)

=head2 C<dislin.winsiz>

  dislin.winsiz (nw, nh)

=head2 C<dislin.wintit>

  dislin.wintit (cstr)

=head2 C<dislin.wmfmod>

  dislin.wmfmod (cmod, ckey)

=head2 C<dislin.world>

  dislin.world ()

=head2 C<dislin.wpixel>

  dislin.wpixel (ix, iy, iclr)

=head2 C<dislin.wpixls>

  dislin.wpixls (iray, ix, iy, nw, nh)

=head2 C<dislin.wpxrow>

  dislin.wpxrow (iray, ix, iy, n)

=head2 C<dislin.wtiff>

  dislin.wtiff (cfil)

=head2 C<dislin.x11fnt>

  dislin.x11fnt (cfont, copt)

=head2 C<dislin.x11mod>

  dislin.x11mod (copt)

=head2 C<dislin.x2dpos>

  dislin.x2dpos (x, y)

Returns number C<x2dpos>.

=head2 C<dislin.x3dabs>

  dislin.x3dabs (x, y, z)

Returns number C<x3dabs>.

=head2 C<dislin.x3dpos>

  dislin.x3dpos (x, y, z)

Returns number C<x3dpos>.

=head2 C<dislin.x3drel>

  dislin.x3drel (x, y, z)

Returns number C<x3drel>.

=head2 C<dislin.xaxgit>

  dislin.xaxgit ()

=head2 C<dislin.xaxis>

  dislin.xaxis (xa, xe, xorg, xstp, nl, cstr, it, nx, ny)

=head2 C<dislin.xaxlg>

  dislin.xaxlg (xa, xe, xorg, xstp, nl, cstr, it, nx, ny)

=head2 C<dislin.xaxmap>

  dislin.xaxmap (xa, xe, xorg, xstp, cstr, it, ny)

=head2 C<dislin.xcross>

  dislin.xcross ()

=head2 C<dislin.xdraw>

  dislin.xdraw (x, y)

=head2 C<dislin.xinvrs>

  dislin.xinvrs (n)

Returns number C<xinvrs>.

=head2 C<dislin.xmove>

  dislin.xmove (x, y)

=head2 C<dislin.xposn>

  dislin.xposn (x)

Returns number C<xposn>.

=head2 C<dislin.y2dpos>

  dislin.y2dpos (x, y)

Returns number C<y2dpos>.

=head2 C<dislin.y3dabs>

  dislin.y3dabs (x, y, z)

Returns number C<y3dabs>.

=head2 C<dislin.y3dpos>

  dislin.y3dpos (x, y, z)

Returns number C<y3dpos>.

=head2 C<dislin.y3drel>

  dislin.y3drel (x, y, z)

Returns number C<y3drel>.

=head2 C<dislin.yaxgit>

  dislin.yaxgit ()

=head2 C<dislin.yaxis>

  dislin.yaxis (ya, ye, yor, ystp, nl, cstr, it, nx, ny)

=head2 C<dislin.yaxlg>

  dislin.yaxlg (ya, ye, yor, ystp, nl, cstr, it, nx, ny)

=head2 C<dislin.yaxmap>

  dislin.yaxmap (ya, ye, yor, ystp, cstr, it, ny)

=head2 C<dislin.ycross>

  dislin.ycross ()

=head2 C<dislin.yinvrs>

  dislin.yinvrs (n)

Returns number C<yinvrs>.

=head2 C<dislin.yposn>

  dislin.yposn (y)

Returns number C<yposn>.

=head2 C<dislin.z3dpos>

  dislin.z3dpos (x, y, z)

Returns number C<z3dpos>.

=head2 C<dislin.zaxis>

  dislin.zaxis (za, ze, zor, zstp, nl, cstr, it, id, nx, ny)

=head2 C<dislin.zaxlg>

  dislin.zaxlg (za, ze, zor, zstp, nl, cstr, it, id, nx, ny)

=head2 C<dislin.zbffin>

  dislin.zbffin ()

=head2 C<dislin.zbfini>

  dislin.zbfini ()

Returns integer C<zbfini>.

=head2 C<dislin.zbflin>

  dislin.zbflin (x1, y1, z1, x2, y2, z2)

=head2 C<dislin.zbftri>

  dislin.zbftri (x, y, z, ic)

=head2 C<dislin.zscale>

  dislin.zscale (za, ze)

=head1 UNIMPLEMENTED

B<Lua Dislin> wraps 596 of the 616 DISLIN functions. The 20 
unimplemented functions fall into two categories: those that make 
little or no sense for Lua, or those that have questionable 
usefulness, and have been set aside for later, if ever.

The I<little or no sense for Lua> functions are:

=over 4

=item C<closfl>

FORTRAN I/O

=item C<dattim>  

Obsolete

=item C<digits>  

Obsolete -- use C<dislin.labdig>

=item C<fcha>

has out cray (dtoa) -- use Lua

=item C<getuni>

returns (FILE *)

=item C<intcha>

has out cray (itoa) -- use Lua

=item C<itmcat>

side affects 1st arg -- use Lua

=item C<lsechk>

Obsolete

=item C<moment>

Obsolete

=item C<openfl>

FORTRAN I/O

=item C<posifl>

FORTRAN I/O

=item C<readfl>

FORTRAN I/O; and has out cray

=item C<scale>

Obsolete -- use C<dislin.axsscl>

=item C<skipfl>

FORTRAN I/O

=item C<swapi2>

has in/out sray; rarely used (not in Python wrapper)

=item C<swapi4>

has in/out iray; rarely used (not in Python wrapper)

=item C<swgcb>

Obsolete

=item C<swgmod>

Obsolete

=item C<tellfl>

FORTRAN I/O

=item C<upstr>

has in/out cray -- use Lua

=item C<winini>

Obsolete

=item C<writfl>

FORTRAN I/O

=back

The I<maybe later> functions are:

=over 4

=item C<csrmov>

has out irays

=item C<csrpos>

has optional args

=item C<csrpts>

has out irays

=item C<getind>

has optional args

=item C<rpixls>

has out iray or cray

=item C<rpxrow>

has out iray or cray

=back

=head1 VERSION

This is B<Lua Dislin> version 10.

=head1 CREDITS

B<Lua Dislin> was developed by Doug Currie, Londonderry, NH, USA.

DISLIN was developed by Helmut Michels at the Max Planck Institute 
for Solar System Research: L<http://www.dislin.de/>

=head1 LICENSE

Note that this license is for the B<Lua Dislin> wrapper. DISLIN itself
has its own license; see L<http://www.dislin.de/>

Copyright (c) 2006-7 Doug Currie, Londonderry, NH, USA
All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, and/or sell copies of the Software, and to permit persons
to whom the Software is furnished to do so, provided that the above
copyright notice(s) and this permission notice appear in all copies 
of the Software and that both the above copyright notice(s) and this
permission notice appear in supporting documentation.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY 
SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.