path: root/ast/plot.c

/*
*class++
*  Name:
*     Plot

*  Purpose:
*     Provide facilities for 2D graphical output.

*  Constructor Function:
c     astPlot
f     AST_PLOT

*  Description:
*     This class provides facilities for producing 2D graphical output.
*     A Plot is a specialised form of FrameSet, in which the base
*     Frame describes a "graphical" coordinate system and is
*     associated with a rectangular plotting area in the underlying
*     graphics system. This plotting area is where graphical output
*     appears. It is defined when the Plot is created.
*
*     The current Frame of a Plot describes a "physical" coordinate
*     system, which is the coordinate system in which plotting
*     operations are specified. The results of each plotting operation
*     are automatically transformed into graphical coordinates so as
*     to appear in the plotting area (subject to any clipping which
*     may be in effect).
*
*     Because the Mapping between physical and graphical coordinates
*     may often be non-linear, or even discontinuous, most plotting
*     does not result in simple straight lines. The basic plotting
*     element is therefore not a straight line, but a geodesic curve
c     (see astCurve, astGenCurve and astPolyCurve). A Plot also provides facilities for
c     drawing markers or symbols (astMark), text (astText) and grid lines
c     (astGridLine). It is also possible to draw curvilinear axes with
c     optional coordinate grids (astGrid).
f     (see AST_CURVE, AST_GENCURVE and AST_POLYCURVE). A Plot also provides facilities
f     for drawing markers or symbols (AST_MARK), text (AST_TEXT) and grid
f     lines (AST_GRIDLINE). It is also possible to draw curvilinear axes
f     with optional coordinate grids (AST_GRID).
*     A range of Plot attributes is available to allow precise control
*     over the appearance of graphical output produced by these
c     functions.
f     routines.
*
*     You may select different physical coordinate systems in which to
*     plot (including the native graphical coordinate system itself)
*     by selecting different Frames as the current Frame of a Plot,
*     using its Current attribute.  You may also set up clipping (see
c     astClip) to limit the extent of any plotting you perform, and
f     AST_CLIP) to limit the extent of any plotting you perform, and
*     this may be done in any of the coordinate systems associated
*     with the Plot, not necessarily the one you are plotting in.
*
*     Like any FrameSet, a Plot may also be used as a Frame. In this
*     case, it behaves like its current Frame, which describes the
*     physical coordinate system.
*
*     When used as a Mapping, a Plot describes the inter-relation
*     between graphical coordinates (its base Frame) and physical
*     coordinates (its current Frame).  It differs from a normal
*     FrameSet, however, in that an attempt to transform points which
*     lie in clipped areas of the Plot will result in bad coordinate
*     values (AST__BAD).

*  Inheritance:
*     The Plot class inherits from the FrameSet class.

*  Attributes:
*     In addition to those attributes common to all FrameSets, every
*     Plot also has the following attributes:
*
*     - Abbrev: Abbreviate leading fields?
*     - Border: Draw a border around valid regions of a Plot?
*     - Clip: Clip lines and/or markers at the Plot boundary?
*     - ClipOp: Combine Plot clipping limits using a boolean OR?
*     - Colour(element): Colour index for a Plot element
*     - DrawAxes(axis): Draw axes for a Plot?
*     - DrawTitle: Draw a title for a Plot?
*     - Escape: Allow changes of character attributes within strings?
*     - Edge(axis): Which edges to label in a Plot
*     - Font(element): Character font for a Plot element
*     - Gap(axis): Interval between linearly spaced major axis values
*     - Grf: Select the graphics interface to use.
*     - Grid: Draw grid lines for a Plot?
*     - Invisible: Draw graphics in invisible ink?
*     - LabelAt(axis): Where to place numerical labels for a Plot
*     - LabelUnits(axis): Use axis unit descriptions in a Plot?
*     - LabelUp(axis): Draw numerical Plot labels upright?
*     - Labelling: Label and tick placement option for a Plot
*     - LogGap(axis): Interval between logarithmically spaced major axis values
*     - LogPlot(axis): Map the plot onto the screen logarithmically?
*     - LogTicks(axis): Space the major tick marks logarithmically?
*     - MajTickLen(axis): Length of major tick marks for a Plot
*     - MinTickLen(axis): Length of minor tick marks for a Plot
*     - MinTick(axis): Density of minor tick marks for a Plot
*     - NumLab(axis): Draw numerical axis labels for a Plot?
*     - NumLabGap(axis): Spacing of numerical axis labels for a Plot
*     - Size(element): Character size for a Plot element
*     - Style(element): Line style for a Plot element
*     - TextGapType: Controls interpretation of TextLabGap and TitleGap
*     - TextLab(axis): Draw descriptive axis labels for a Plot?
*     - TextLabGap(axis): Spacing of descriptive axis labels for a Plot
*     - TickAll: Draw tick marks on all edges of a Plot?
*     - TitleGap: Vertical spacing for a Plot title
*     - Tol: Plotting tolerance
*     - Width(element): Line width for a Plot element

*  Functions:
c     In addition to those functions applicable to all FrameSets, the
c     following functions may also be applied to all Plots:
f     In addition to those routines applicable to all FrameSets, the
f     following routines may also be applied to all Plots:
*
c     - astBBuf: Begin a new graphical buffering context
c     - astBorder: Draw a border around valid regions of a Plot
c     - astBoundingBox: Returns a bounding box for previously drawn graphics
c     - astClip: Set up or remove clipping for a Plot
c     - astCurve: Draw a geodesic curve
c     - astEBuf: End the current graphical buffering context
c     - astGenCurve: Draw a generalized curve
c     - astGetGrfContext: Get the graphics context for a Plot
c     - astGrfPop: Retrieve previously saved graphics functions
c     - astGrfPush: Save the current graphics functions
c     - astGrfSet: Register a graphics routine for use by a Plot
c     - astGrid: Draw a set of labelled coordinate axes
c     - astGridLine: Draw a grid line (or axis) for a Plot
c     - astMark: Draw a set of markers for a Plot
c     - astPolyCurve: Draw a series of connected geodesic curves
c     - astRegionOutline: Draw the outline of an AST Region
c     - astText: Draw a text string for a Plot
f     - AST_BBUF: Begin a new graphical buffering context
f     - AST_BORDER: Draw a border around valid regions of a Plot
f     - AST_BOUNDINGBOX: Returns a bounding box for previously drawn graphics
f     - AST_CLIP: Set up or remove clipping for a Plot
f     - AST_CURVE: Draw a geodesic curve
f     - AST_EBUF: End the current graphical buffering context
f     - AST_GENCURVE: Draw a generalized curve
f     - AST_GETGRFCONTEXT: Get the graphics context for a Plot
f     - AST_GRFPOP: Retrieve previously saved graphics functions
f     - AST_GRFPUSH: Save the current graphics functions
f     - AST_GRFSET: Register a graphics routine for use by the Plot class
f     - AST_GRID: Draw a set of labelled coordinate axes
f     - AST_GRIDLINE: Draw a grid line (or axis) for a Plot
f     - AST_MARK: Draw a set of markers for a Plot
f     - AST_POLYCURVE: Draw a series of connected geodesic curves
f     - AST_REGIONOUTLINE: Draw the outline of an AST Region
f     - AST_TEXT: Draw a text string for a Plot

*  Graphical Elements:
*     The colour index, character font, character size, line style and
*     line width used for plotting can be set independently for
*     various elements of the graphical output produced by a Plot.
*     The different graphical elements are identified by appending the
*     strings listed below as subscripts to the Plot attributes
*     Colour(element), Font(element), Size(element), Style(element)
*     and Width(element). These strings are case-insensitive and
*     unambiguous abbreviations may be used. Elements of the graphical
*     output which relate to individual axes can be referred to either
*     independently (e.g. "(Grid1)" and "(Grid2)" ) or together (e.g.
*     "(Grid)"):
*
c     - Axes: Axis lines drawn through tick marks using astGrid
f     - Axes: Axis lines drawn through tick marks using AST_GRID
c     - Axis1: Axis line drawn through tick marks on axis 1 using astGrid
f     - Axis1: Axis line drawn through tick marks on axis 1 using AST_GRID
c     - Axis2: Axis line drawn through tick marks on axis 2 using astGrid
f     - Axis2: Axis line drawn through tick marks on axis 2 using AST_GRID
c     - Border: The Plot border drawn using astBorder, astGrid or astRegionOutline
f     - Border: The Plot border drawn using AST_BORDER, AST_GRID or AST_REGIONOUTLINE
c     - Curves: Geodesic curves drawn using astCurve, astGenCurve or astPolyCurve
f     - Curves: Geodesic curves drawn using AST_CURVE, AST_GENCURVE or AST_POLYCURVE
c     - Grid: Grid lines drawn using astGridLine or astGrid
f     - Grid: Grid lines drawn using AST_GRIDLINE or AST_GRID
c     - Grid1: Grid lines which cross axis 1, drawn using astGridLine or astGrid
f     - Grid1: Grid lines which cross axis 1, drawn using AST_GRIDLINE or AST_GRID
c     - Grid2: Grid lines which cross axis 2, drawn using astGridLine or astGrid
f     - Grid2: Grid lines which cross axis 2, drawn using AST_GRIDLINE or AST_GRID
c     - Markers: Graphical markers (symbols) drawn using astMark
f     - Markers: Graphical markers (symbols) drawn using AST_MARK
c     - NumLab: Numerical axis labels drawn using astGrid
f     - NumLab: Numerical axis labels drawn using AST_GRID
c     - NumLab1: Numerical labels for axis 1 drawn using astGrid
f     - NumLab1: Numerical labels for axis 1 drawn using AST_GRID
c     - NumLab2: Numerical labels for axis 2 drawn using astGrid
f     - NumLab2: Numerical labels for axis 2 drawn using AST_GRID
c     - Strings: Text strings drawn using astText
f     - Strings: Text strings drawn using AST_TEXT
c     - TextLab: Descriptive axis labels drawn using astGrid
f     - TextLab: Descriptive axis labels drawn using AST_GRID
c     - TextLab1: Descriptive label for axis 1 drawn using astGrid
f     - TextLab1: Descriptive label for axis 1 drawn using AST_GRID
c     - TextLab2: Descriptive label for axis 2 drawn using astGrid
f     - TextLab2: Descriptive label for axis 2 drawn using AST_GRID
c     - Ticks: Tick marks (both major and minor) drawn using astGrid
f     - Ticks: Tick marks (both major and minor) drawn using AST_GRID
c     - Ticks1: Tick marks (both major and minor) for axis 1 drawn using astGrid
f     - Ticks1: Tick marks (both major and minor) for axis 1 drawn using AST_GRID
c     - Ticks2: Tick marks (both major and minor) for axis 2 drawn using astGrid
f     - Ticks2: Tick marks (both major and minor) for axis 2 drawn using AST_GRID
c     - Title: The Plot title drawn using astGrid
f     - Title: The Plot title drawn using AST_GRID

*  Copyright:
*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
*     Research Councils
*     Copyright (C) 2009 Science & Technology Facilities Council.
*     All Rights Reserved.

*  Licence:
*     This program is free software: you can redistribute it and/or
*     modify it under the terms of the GNU Lesser General Public
*     License as published by the Free Software Foundation, either
*     version 3 of the License, or (at your option) any later
*     version.
*
*     This program is distributed in the hope that it will be useful,
*     but WITHOUT ANY WARRANTY; without even the implied warranty of
*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*     GNU Lesser General Public License for more details.
*
*     You should have received a copy of the GNU Lesser General
*     License along with this program.  If not, see
*     <http://www.gnu.org/licenses/>.

*  Authors:
*     DSB: D.S. Berry (Starlink)
*     RFWS: R.F. Warren-Smith (Starlink)

*  History:
*     18-SEP-1996 (DSB):
*        Original version.
*     25-FEB-1997 (RFWS):
*        Tidied all public prologues.
*     18-AUG-1997 (DSB):
*        Changes made to ensure that the first label on each axis is
*        never abbreviated, and to avoid segmentation violation when NumLab
*        is set to zero.
*     1-SEP-1997 (DSB):
*        astGetGap changed so that it returns the default value which will
*        be used (instead of AST__BAD) if no value has been set for Gap.
*        The Border attribute modified so that it is off (zero) by default.
*     19-SEP-1997 (DSB):
*        o  Check that something has been plotted before using the bounding
*        box to determine title and label positions.
*        o  Fixed bug which caused a tick mark at the pole to be draw at
*        a random angle.
*        o  The size of the increment used to determine the tangent to a grid
*        line at the position to a label has been reduced to make sure the
*        labls are drawn parallel to grid line.
*        o  Correct the logic for catering with reversed axes when determining
*        the displacement of a label's reference point from the associated
*        axis.
*        o  Corrected logic which determined if two numerical labels overlap.
*        o  Corrected logic for determining when to abbreviate numerical
*        labels.
*        o  Use of strtok replaced by local function FindWord.
*        o  Correct logic which determines which side of the axis to draw
*        tick marks when using interior labelling.
*        o  If the base Frame of the FrameSet supplied to astPlot has more
*        than 2 axes, then use a sub-frame formed from the first two axes,
*        instead of simply reporting an error.
*        o  If the current Frame of the Plot supplied to astGrid or
*        astBorder has more than 2 axes, then use a sub-frame formed from
*        the first two axes, instead of simply reporting an error.
*        o  Default for Border is now to draw the border if exterior
*        Labelling is used, but not to draw it if interior labelling is
*        used.
*        o  Public astGet function now returns actual used values for all
*        attributes. Protected astGetXyz functions still return the requested
*        value (which may differ from the used value), or the "unset" value
*        if no value has been set for the attribute.
*        o  The defaults for Edge now depend on Labelling. If exterior
*        labelling was requested but cannot be produced using defaults of
*        Edge(1)=Bottom and Edge(2)=Left, then these default Edge values
*        are swapped. If exterior labelling is still not possible, the
*        original default Edge values are re-instated.
*        o  Unset attributes which use dynamic defaults are now flagged as
*        "unhelpful" in the dump function.
*        o  Added attribute Escape which allows text strings to include
*        escape sequences (see function GrText). This attribute and
*        associated functionality is currently not available for use, search
*        for all occurences of ENABLE-ESCAPE for instructions on how to
*        enable the facilities.
*        o  Strings now used instead of integers to represent "choice"
*        attributes externally (eg Edge and Labelling).
*     24-NOV-1997 (DSB):
*        o  Fixed bug in function Grid which caused units to be included in
*        SkyFrame axis labels by default.
*        o  Replaced calls to DrawText by calls to astGText, and replaced
*        references to "U" and "D" justifications by "T" and "B". This
*        stops labels drifting to the bottom left when GAIA zooms.
*     23-MAR-1998 (DSB):
*        Added extra checks on global status into routine Grid to avoid
*        segmentation violations occuring due to null pointers being used.
*     10-JUN-1998 (DSB):
*        Modify DrawTicks so that ticks are drawn closer to singularities
*        than previously. Also normalise this constraint to the screen size
*        rather than the length of a major tick mark.
*     28-OCT-1998 (DSB):
*        o  Added method astPolyCurve.
*        o  Extract the Current Frame from the Plot prior to using Frame
*        methods such as astOffset, astNorm, etc.
*        o  PlotLabel modified to ensure labels are abbreviated even if
*        they are next to the "root" label (i.e. the label with most
*        trailing zeros).
*        o  Modified description of Width attribute. Width no longer gives
*        the absolute line width in inches. Instead it is a scale factor,
*        where 1.0 corresponds to a "typical thin line" on the device.
*        o  Modified LabelUnits attribute so that the default value is zero
*        for SkyAxes and non-zero for other Axes.
*     10-DEC-1998 (DSB):
*        Modified all calls to the "pow" maths function to avoid using
*        literal constants as arguments. This seems to cause segmentation
*        violations on some systems.
*     16-JUL-1999 (DSB):
*        Fixed memory leaks in EdgeCrossings and EdgeLabels.
*     16-SEP-1999 (DSB):
*        Avoid writing out clipping limits if they are undefined.
*     12-OCT-1999 (DSB):
*        o  Modified use of the NumLab attribute so that setting it to zero
*        does not prevent exterior labels from being produced.
*        o  Allow length of tick marks to be specified separately for
*        both axes.
*     13-OCT-2000 (DSB):
*        o Purge zero length sections from CurveData structures.
*        o Increase tolerance for edge labels from 0.0005 to 0.005.
*     9-JAN-2001 (DSB):
*        o  Change argument "in" for astMark and astPolyCurve from type
*        "const double (*)[]" to "const double *".
*        o  Check success of astReadString before using the returned
*        pointer.
*        o  Change method for choosing default LabelAt values to ignore
*        values which produce no visible labels.
*     10-JAN-2001 (DSB):
*        o  Modified FindMajTick to choose the size of fillable holes in
*        the axis range on the basis of the number of ticks on the axis.
*        This avoids holes being visible in the displayed tick marks when
*        using very small gaps.
*     22-MAY-2001 (DSB):
*        Added a check when using interior labelling, to ensure that the
*        most appropriate edges are used for text labels.
*     13-JUN-2001 (DSB):
*        Added public method astGenCurve, astGrfSet, astGrfPop, astGrfPush.
*        Made DrawAxes attribute axis specific.
*     4-JUL-2001 (DSB):
*        The Crv function used to have a restriction that if *any*
*        subsection was very short, then *none* of the subsections were
*        subdivided. This meant that long subsections which needed
*        subdividing were not subdivided if there was also a very short
*        subsection. To get round this problem the restriction was changed
*        to "if *all* subsections are very short then none are divided.
*        This was implemented by changing dl2_min to dl2_max, and adding
*        a check for very short segments (which are then not sub-divided).
*     16-AUG-2001 (DSB):
*        Remove the check for very short segments introduced above, as it
*        caused south pole tan projection to include some spurious lines.
*     20-SEP-2001 (DSB):
*        - Initialize baseframe to NULL in astInitPlot (prevents segvios).
*        - Modified astInitPlot to allow the "frame" argument to the astPlot
*        constructor to be a Plot.
*     10-JAN-2002 (DSB):
*       - Added axis-specific graphical elements "axis1", "axis2", etc.
*       - FullForm returns a match without ambiguity if the test string
*       matches an option exactly, including length.
*     31-JAN-2002 (DSB):
*       - Added RejectOOB to reject tick marks which are not in their primary
*       domain.
*     14-FEB-2002 (DSB):
*       - Relaxed the conditions for equality within the EQUALS macro.
*       Guard aginst no ticks being found.
*     18-FEB-2002 (DSB):
*       - Make a permanent copy of any old axis format string in TickMarks.
*       Previously a mere pointer into the astGet string buffer was stored,
*       which could be over-written after many calls to astGet.
*       - If a user specifies an axis format, use it whether or not it
*       results in any identical adjacent labels.
*     4-MAR-2002 (DSB):
*       - Made fairly extesive changes to the creation and use of tick
*       mark values in order to circumvent problems with CAR projections,
*       and "1 to many" mappings (such as 2D cartesian->polar). The
*       policy now is that axis normalization is only performed when
*       necessary (i.e. to create labels for display, etc). Tick mark
*       values are stored and handled as non-normalized values as much as
*       possible.
*     13-JUN-2002 (DSB):
*       Modified Norm1 to prevent major tick value from being removed if
*       the supplied reference value is out of bounds, resulting in the
*       Mapping producing bad values
*     14-JUN-2002 (DSB):
*       Re-wrote PlotLabels to improve abbreviation of labels and the
*       choice of which labels not to print.
*     14-AUG-2002 (DSB):
*       - Added method astBoundingBox.
*       - Added attribute Invisible.
*       - Correct handling of "axis specific" plot elements cuch as
*       (Axis1), (Axis2), etc.
*     12-SEP-2002 (DSB):
*       - Modified Map1 to remove slow normalization method (it is now
*       faster but the changes result in some longer-than-needed grids
*       lines when (e.g.) plotting pixel coordins in Polar coords).
*       - Modified Axlot so that SkyFrames positions which are out of
*       their normal ranges are not rejected by Map1.
*     10-OCT-2002 (DSB):
*       grfAttrs:Modified to test element attributes explicitly using the
*       relevant TestUse<attr> functions, instead of relying on the
*       "GetUse<attr>" function returning the NO<attr> constant if not set.
*       - Modified Axplot so that SkyFrames positions which are out of
*       their normal ranges are not rejected by Map1.
*       - Only use tick marks which are within the axis range given by the
*       Bottom and Top Axis attributes.
*       - Norm1: If the normalized current frame coords are bad, do not
*       reinstate the original unnormalized values. For instance, current
*       Frame values which are outside the valid domain of the projection
*       should result in bad values when normalized, not the original
*       good values. The original comment stated "If the normalization
*       produced bad coords (e.g. as may happen if the supplied refernce
*       value corresponds to a point on the line through the tick mark
*       which is outside the valid region of the mapping) leave the original
*       tick mark values unchanged".
*       - GetTicks: Limit maxticks to be no less than 8.
*     8-JAN-2003 (DSB):
*        - Changed private InitVtab method to protected astInitPlotVtab
*        method.
*        - Use private IsASkyFrame method in place of astIsASkyFrame.
*        - Modify PlotLabels to excluding exponents when counting trailing
*        zeros, and also to pad trailing fields with trailing zeros up to
*        the max number of decimal places when estimating label priorities.
*        - Modified Overlap to ensure that axis labels are speced by at
*        least two spaces.
*     22-JAN-2003 (DSB):
*        - Modified PlotLabels so that labels are rejected in a regular
*        pattern rather than semi-random.
*        - Modified the way PlotLabels abbreviates leading fields.
*        - Introdued the skipbad parameter for the Crv function, in order
*        to provide some degree of protection against the Crv algorithm
*        skipping over small sections of valid coordinates (such as when
*        a curve crosses the plot very close to a corner of the plot).
*     25-MAR-2003 (DSB):
*        - Modified FindMajTicks to avoid losing tick marks when dealing
*        with high precision data.
*     8-AUG-2003 (DSB):
*        - Modified PlotLabels to ensure that the root label for the
*        second axis is not omitted due to it overlapping a label from
*        the first axis (a different root label is now chosen if this would
*        be the case).
*        - Modify FindMajTicks to avoid tick marks which should be at
*        exactly zero being placed at some very small non-zero axis value.
*     22-OCT-2003 (DSB):
*        - DrawTicks modified to correctly reset graphical attributes and
*        pass on to the next axis if an axis has zero length major and minor
*        tick marks.
*     9-JAN-2004 (DSB):
*        DrawGrid: Report error if no grid curves can be drawn.
*        AxPlot: Initialise returned CDATA structure before checking argument
*        validity.
*        GetTicks: Calculate the reference value on the other axis using
*        function "Typical" rather than simply using the man of the supplied
*        values (the supplied values may be clustered around 0 and 2*PI if the
*        field is centred on the origin, resulting in the mean being at about
*        1.PI and therefore inappropriate).
*     13-JAN-2004 (DSB):
*        - Added LogPlot attribute, and the facility for mapping the base
*        coordinate system logarithmically onto the plotting area instead of
*        linearly.
*        - Added LogTicks attribute, and the facility for spacing the
*        major tick marks logarithmically instead of linearly.
*        - Added LogGap attribute, and the facility for storing separate
*        gap sizes for linear and log tick spacing.
*     15-JAN-2004 (DSB):
*        - Added LogLabel attribute.
*        - Re-instated the inclusion of escape sequences in strings (see
*        function GrText).
*     12-FEB-2004 (DSB):
*        - RightVector: Corrected usage of chh and chv.
*        - GQch and GScales: Check that values returned by grf module are
*          usable.
*        - DrawAxis: Extend axis section by one section (if possible) at
*        each end (overcomes problems where the axis does not reach a pole).
*        - DrawAxis: Check axis does not extend beyond a pole.
*        - Labels: Correct logic of loop which plots interior labels
*        (previously it missed out labels if there were only 3)
*        - Allow for some rounding error in FindMajTicks when comparing an
*        axis value with a loweror upper axis limit.
*     19-FEB-2004 (DSB):
*        - Reduced the dynamic range restriction for log ticks from 2 decades
*        to 1.
*        - Temporarily clear any error status before re-instating the
*        original Format in TickMarks.
*        - Add LogTicks to the GetAttrib function so that the value of the
*        LogTicks attribute can be got by the public.
*        - Modify Crv to include a check that he vector scale has not
*        changed much between adjacent segments.
*        - Modify Crv so that a segment is only subdivided if at least
*        half of the subsegments are longer than the shortest significant
*        length. Also put a restriction on subdivision so that
*        subdivision only occurs if the bounding box of the segment being
*        sub-divided is smaller than the bounding box of its parent
*        segment.
*     27-FEB-2004 (DSB):
*        - Reduce the default Tol value from 0.001 to 0.01 in order to
*        speed up curve drawing..
*        - Use 0.1*Tol in Boundary because the boundary tracing algorithm
*        seems to produce much worse visible errors than it should do for a
*        given Tol.
*     2-MAR-2004 (DSB):
*        - Corrected handling of bounding boxes in Crv so that
*        subdivision is allowed if the bounding box shrinks on only 1 axis
*        (previously required shrinkage on both axes but this fails if
*        all the points are on a horizontal or vertical line).
*        - Modified FindMajTicks to use a better algorithm for finding an
*        appropriate nfill value (previously logplot=1 axes could have
*        unfilled holes at the high end).
*        - Modified GetTicks so that FindMajTicks is not called
*        repeatedly with the same gap size.
*        - Modify AxPlot/Map1 so that the axis curve is sampled logarithmically
*        if the corresponding axis is mapped logarithmically.
*     10-MAR-2004 (DSB):
*        - Modified Typical to give less weight to vaalues close to the
*        edges of the range covered by the plotting area.
*        - Increased minimum angle between curve and edge required to
*        create an edge label from 3 degs to 5 degs.
*        - Modified PlotLabels to ignore duplicate adjacent labels which
*        determining overlap of labels.
*     17-MAR-2004 (DSB):
*        - Modified Typical to give normal weight to edge bins in
*        histogram if these bins contain all the counts.
*        - Modified DrawTicks to add extra minor ticks below first major
*        tick value and above last major tick value.
*        - Norm1 can reject usable tick mark values because of an
*        inappropriate value being used on the other axis (i.e. one for
*        which the position is undefined in grapics coords). Therfoer
*        Norm1 has been modified to use 3 different reference values
*        in an attempt to find one which gives good axis values.
*     25-AUG-2004 (DSB):
*        - Correct handling of "fmt" pointer in TickMarks function (identified
*        and reported by Bill Joye).
*     14-SEP-2004 (DSB):
*        - In EdgeLabels change definition of "distinct labels". Used to
*        be that labels were distinct if they had different formatted
*        labels. Now they are distinct if they have different floating
*        point numerical values. Fixes a bug reported by Micah Johnson.
*        - TickMarks re-structured to optimise the precision (no. of digits)
*        even if a value has been assigned for the Format attribute, but only
*        if the format specifier includes a wildcard precision specifier. For
*        instance, to get graphical separators a format must be specified
*        which included the "g" flag. As things were, this would prevent
*        the optimisation of the digits value. Can now use "dms.*g" to
*        allow the number of digits to be optimised.
*     29-SEP-2004 (DSB):
*        - In FindMajTicks, begin the process of increasing "nfill" from
*        a value of zero rather than one (in many cases no filling is
*        needed).
*        - In GetTicks (linear tick marks section) ensure that 10
*        *different* gap sizes are used before giving up. Previously, the
*        10 tests could include duplicated gap values.
*     8-NOV-2004 (DSB):
*        - In Norm1, try more alternative "other axis" values before
*        accepting that a tick mark value cannot be normalised.
*     2-FEB-2005 (DSB):
*        - Avoid using astStore to allocate more storage than is supplied
*        in the "data" pointer. This can cause access violations since
*        astStore will then read beyond the end of the "data" area.
*     15-MAR-2005 (DSB):
*        - Modified GridLines to use appropriate algorithm for choosing
*        start of grid lines in cases where one axis has logarithmic tick
*        spacing and the other has linear tick spacing.
*     21-MAR-2005 (DSB):
*        - Added the Clip attribute.
*     12-JUL-2005 (DSB):
*        - Modified AxPlot so that Map1 only normalises if neither axis
*        is a SkyAxis. Previously it normalised if either axis was not a
*        SkyAxis.
*     7-DEC-2005 (DSB):
*        Free memory allocated by calls to astReadString.
*     18-JAN-2006 (DSB)
*        Add Abbrev attribute.
*     14-FEB-2006 (DSB)
*        Correct EdgeLabels to use gap size rather than EQUAL macro when
*        comparing label values.
*     17-FEB-2006 (DSB)
*        Added escape sequences "%h+" and "%g+".
*     21-MAR-2006 (DSB)
*        Added extra status checks in TickMarks.
*     18-MAY-2006 (DSB)
*        Trans: use correct PointSet when tranforming to arbitrary
*        clipping frame.
*     26-MAY-2006 (DSB)
*        Added LabelAt to TestAttrib.
*     2-JUN-2006 (DSB)
*        - In MAKE_GET2, return the set value if a value has been set
*        without recalculating the defaults.
*        - Fix bug that could cause segvio in Grid if clipping is used.
*     5-JUN-2006 (DSB)
*        Do not change the box returned by astBoundBox as a consequence
*        of calling astGetAttrib.
*     19-JUN-2006 (DSB)
*        Changed the default line 0.0 from zero to 1.0.
*     22-JUN-2006 (DSB)
*        Include axis textual labels and title in the bounding box
*        created by AST_GRID and returned by AST_BOUNDINGBOX.
*     26-JUN-2006 (DSB)
*        Set the Direction attribute in the base Frame of a Plot if an
*        axis is reversed.
*     29-JUN-2006 (DSB)
*        - Guard against astGap calls that reach a minimum gap size.
*        - Sort out splitting of long axis labels (such as date/time
*        strings produced by TimeFrames).
*     30-JUN-2006 (DSB)
*        If abbreviating labels, display the last field for identical
*        neighbours rather than the whole value.
*     10-JUL-2006 (DSB)
*        Make astStripEscapes public so it can be used by the NDF library.
*     7-AUG-2006 (DSB)
*        Increase the number of attempts to find a new gap size from 5 to
*        25 in GetTicks.
*     24-OCT-2006 (DSB)
*        Add the ForceExterior attribute so that SPLAT can have external
*        axes even if there are no usable horizontal axis ticks (as requested
*        by PWD). Currently this attribute is not included in the public
*        documentation, as it may cause problems. If it seems to work OK
*        then it can be made public.
*     25-JAN-2006 (DSB)
*        Do not draw ticks marks that start outside the bounds of the
*        axis they are labelling.
*     27-FEB-2007 (DSB)
*        - Change nominal Crv_scerr value from 5.0 to 1.5 (this avoids gaps
*        in HPX grid plots being bridged by grid lines).
*        - Double the dimension of the grid used by GoodGrid to avoid
*        missing the pointy bits in a HPX projection.
*     17-MAY-2007 (DSB)
*        Exclude corner positions when determining the range of axis
*        values covered by the plot. This gives better default gap sizes.
*     11-JUN-2007 (DSB)
*        Plug memory leaks.
*     20-JUN-2007 (DSB)
*        - Add attribute GrfContext.
*        - Pass the GrfContext attribute value to each external grf function.
*        External code that uses the astGrfSet function must be changed
*        so that the external grf functions registered using astGrfSet
*        accept this new parameter.
*     21-JUN-2007 (DSB)
*        - Change GrfContext to be an Object rather than an integer.
*     22-JUN-2007 (DSB)
*        - Do not dump the GrfContext Object since it may cause an
*        infinite dumping loop.
*        - Allow a NULL vtab to be supplied when initialising a Plot
*        structure. This causes the vtab defined locally within this
*        class to be used so that the new object behaves as a simple Plot.
*     25-JUN-2007 (DSB)
*        - Free the graphics context object when then the Plot is deleted.
*        - Fix memory leak in FullForm.
*        - Since the grfcontext object is only used by external code, store
*          a public object identifier for it in the Plot structure rather
*          than a true C pointer.
*     26-JUN-2007 (DSB)
*        Honour the LabelUp attribute value even if labels are drawn
*        around the edges of the plot.
*     28-JUN-2007 (DSB)
*        - Make all axis attribute arrays 3 elements long rather than 2.
*        - Add the protected methods astCopyPlotDefaults and astMirror.
*        - Add public method astGetGrfContext, remove astSetGrfContext.
*        - Fix memory leak.
*     6-SEP-2007 (DSB):
*        Dump and load any user-specified tick mark values.
*     20-OCT-2009 (DSB):
*        - Modify SplitValue so that it only splits long values if
*        previous long values were split, or if the value contains a
*        space.
*        - Take account of zero height bounding boxes in UpdateConcat.
*        - Correct Dump so that it dumps attributes for all available
*        axes (2 for a Plot, 3 for a Plot3D).
*     12-JAN-2010 (DSB):
*        Fix various memory leaks.
*     4-MAR-2011 (DSB):
*        - Added grf functions BBuf and EBuf.
*        - Added public method astBBuf and astEBuf.
*     23-AUG-2011 (DSB):
*        - If exterior labelling was requested but would produced too
*        few labels, only swap to interior labelling if doing so would
*        allow more labels to be drawn (i.e. do not swap to interior if
*        it does not gain us anything).
*        - Slightly decrease the dynamic range of an axis needed to produce
*        logarithmic ticks (this is to avoid problems with round errors).
*     6-OCT-2011 (DSB):
*        - Prevent grf qch and scales functions being called lots of times
*        during each drawing operation (since the information returned by
*        these functions will not change during the course of a single drawing
*        operation).
*     11-OCT-2011 (DSB):
*        - Combine multiple continuous polylines into a single polyline
*        before calling the grf polyline function. Reducing the number of
*        calls to the underlying graphics system can make a big difference
*        if the graphics system is written in an interpreted language
*        such as python.
*        - Take account of differing axis scales when rotating vectors by
*        90 degrees.
*     12-OCT-2011 (DSB):
*        - Fix the change made yesterday to correct rotation of numerical axis
*        rotations. I forgot that the astGText function in the grf module
*        expects the up vector in equally scaled coords, not graphics coords.
*        - Take account of unequal axis scales when working out the
*        length of each grid curve.
*     15-OCT-2011 (DSB):
*        Always check that the grf module implements the scales function
*        before trying to invoke the scales function.
*     21-MAY-2012 (DSB):
*        Correct text strings used to represent the "Labelling" attribute
*        within dumps of a Plot. Previously they were reversed.
*     7-JUN-2012 (DSB):
*        Speed up plotting of CmpRegion boundaries by splitting the
*        CmpRegion up into a set of disjoint Regions, and plotting each
*        one separately.
*     16-JUN-2014 (DSB):
*        - Prevent seg fault in PlotLabels caused by accessing
*        uninitialised "atext" field stored within purged labels.
*        - Choose a label with non-negative priority as the fall-back root label.
*     17-APR-2015 (DSB):
*        Added method astRegionOutline.
*     20-APR-2015 (DSB):
*        Draw Regions with higher accuracy, because Regions (i.e. Polygons)
*        can be very non-smooth.
*     25-OCT-2018 (DSB):
*        Added attribute TextGapType for Angus Comrie (IDIA).
*     11-DEC-2018 (DSB):
*        In Crv, draw a segment as a single line if all segments are good and
*        the total of all segments os very short, regardless of anything else.
*        Without this, we were getting situations where the curve was being
*        subdivied for too much to produce a polyline with a huge number of
*        points for no good reason (e.g. when drawing the boundary of a Moc).
*        Plotting all these unnecessary points slows down the drawing badly
*        with soime devices (e.g. GWM).
*class--
*/

/* Module Macros. */
/* ============== */
/* Set the name of the class we are implementing. This indicates to the header
   files that define class interfaces that they should make "protected"
   symbols available. */
#define astCLASS Plot

/* Values for constants used in this class. */
#define CRV_NSEG       14 /* No. of curve segments drawn by function Crv */
#define CRV_NPNT       15 /* CRV_NSEG plus one */
#define CRV_MXENT      10 /* Max. no. of recursive entries into function Crv */
#define MAJTICKS_OPT   10 /* Optimum number of major axiss or grid lines */
#define MAJTICKS_MAX   14 /* Max. number of major ticks or grid lines */
#define MAJTICKS_MIN    6 /* Min. number of major ticks or grid lines */
#define EDGETICKS_DIM 100 /* No. of edge samples used to find tick marks */
#define LEFT            0 /* Id for the left edge of the plotting area */
#define TOP             1 /* Id for the top edge of the plotting area */
#define RIGHT           2 /* Id for the right edge of the plotting area */
#define BOTTOM          3 /* Id for the bottom edge of the plotting area */
#define NOSTYLE      -999 /* A value which represents a null Style value */
#define NOWIDTH     -99.9 /* A value which represents a null Style value */
#define NOFONT       -999 /* A value which represents a null Style value */
#define NOCOLOUR     -999 /* A value which represents a null Style value */
#define NOSIZE      -99.9 /* A value which represents a null Style value */

#if defined(THREAD_SAFE)
#define GLOBALS_PROTO , AstGlobals *
#define GLOBALS_ARG , AstGlobals *AST__GLOBALS
#define GLOBALS_NAME , AST__GLOBALS
#else
#define GLOBALS_PROTO
#define GLOBALS_ARG
#define GLOBALS_NAME
#endif

/*
*
*  Name:
*     MAKE_CLEAR

*  Purpose:
*     Implement a method to clear a single value in a multi-valued attribute.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot.h"
*     MAKE_CLEAR(attr,component,assign,nval)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Clear<Attribute>( AstPlot *this, int axis )
*
*     and an external interface function of the form:
*
*        void astClear<Attribute>_( AstPlot *this, int axis )
*
*     which implement a method for clearing a single value in a specified
*     multi-valued attribute for an axis of a Plot.

*  Parameters:
*     attr
*        The name of the attribute to be cleared, as it appears in the function
*        name (e.g. LabelAt in "astClearLabelAt").
*     component
*        The name of the class structure component that holds the attribute
*        value.
*     assign
*        An expression that evaluates to the value to assign to the component
*        to clear its value.
*     nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_CLEAR(attr,component,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Clear##attr( AstPlot *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= ( nval ? nval : astGetNin( this ) ) ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astClear" #attr, astGetClass( this ), \
                axis + 1, ( nval ? nval : astGetNin( this ) ) ); \
\
/* Assign the "clear" value. */ \
   } else { \
      this->component[ axis ] = (assign); \
   } \
} \
\
/* External interface. */ \
/* ------------------- */ \
void astClear##attr##_( AstPlot *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Invoke the required method via the virtual function table. */ \
   (**astMEMBER(this,Plot,Clear##attr))( this, axis, status ); \
}


/*
*
*  Name:
*     MAKE_GET

*  Purpose:
*     Implement a method to get a single value in a multi-valued attribute.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot.h"
*     MAKE_GET(attr,type,bad_value,assign,nval)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static <Type> Get<Attribute>( AstPlot *this, int axis )
*
*     and an external interface function of the form:
*
*        <Type> astGet<Attribute>_( AstPlot *this, int axis )
*
*     which implement a method for getting a single value from a specified
*     multi-valued attribute for an axis of a Plot.

*  Parameters:
*     attr
*        The name of the attribute whose value is to be obtained, as it
*        appears in the function name (e.g. Label in "astGetLabel").
*     type
*        The C type of the attribute.
*     bad_value
*        A constant value to return if the global error status is set, or if
*        the function fails.
*     assign
*        An expression that evaluates to the value to be returned. This can
*        use the string "axis" to represent the zero-based value index.
*     nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_GET(attr,type,bad_value,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static type Get##attr( AstPlot *this, int axis, int *status ) { \
   type result;                  /* Result to be returned */ \
\
/* Initialise */ \
   result = (bad_value); \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= ( nval ? nval : astGetNin( this ) ) ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astGet" #attr, astGetClass( this ), \
                axis + 1, ( nval ? nval : astGetNin( this ) ) ); \
\
/* Assign the result value. */ \
   } else { \
      result = (assign); \
   } \
\
/* Check for errors and clear the result if necessary. */ \
   if ( !astOK ) result = (bad_value); \
\
/* Return the result. */ \
   return result; \
} \
/* External interface. */ \
/* ------------------- */  \
type astGet##attr##_( AstPlot *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return (bad_value); \
\
/* Invoke the required method via the virtual function table. */ \
   return (**astMEMBER(this,Plot,Get##attr))( this, axis, status ); \
}

/*
*
*  Name:
*     MAKE_SET

*  Purpose:
*     Implement a method to set a single value in a multi-valued attribute
*     for a Plot.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot.h"
*     MAKE_SET(attr,type,component,assign,nval)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Set<Attribute>( AstPlot *this, int axis, <Type> value )
*
*     and an external interface function of the form:
*
*        void astSet<Attribute>_( AstPlot *this, int axis, <Type> value )
*
*     which implement a method for setting a single value in a specified
*     multi-valued attribute for a Plot.

*  Parameters:
*      attr
*         The name of the attribute to be set, as it appears in the function
*         name (e.g. LabelAt in "astSetLabelAt").
*      type
*         The C type of the attribute.
*      component
*         The name of the class structure component that holds the attribute
*         value.
*      assign
*         An expression that evaluates to the value to be assigned to the
*         component.
*      nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_SET(attr,type,component,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void Set##attr( AstPlot *this, int axis, type value, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= ( nval ? nval : astGetNin( this ) ) ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astSet" #attr, astGetClass( this ), \
                axis + 1, ( nval ? nval : astGetNin( this ) ) ); \
\
/* Store the new value in the structure component. */ \
   } else { \
      this->component[ axis ] = (assign); \
   } \
} \
\
/* External interface. */ \
/* ------------------- */ \
void astSet##attr##_( AstPlot *this, int axis, type value, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Invoke the required method via the virtual function table. */ \
   (**astMEMBER(this,Plot,Set##attr))( this, axis, value, status ); \
}

/*
*
*  Name:
*     MAKE_TEST

*  Purpose:
*     Implement a method to test if a single value has been set in a
*     multi-valued attribute for a class.

*  Type:
*     Private macro.

*  Synopsis:
*     #include "plot.h"
*     MAKE_TEST(attr,assign,nval)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static int Test<Attribute>( AstPlot *this, int axis )
*
*     and an external interface function of the form:
*
*        int astTest<Attribute>_( AstPlot *this, int axis )
*
*     which implement a method for testing if a single value in a specified
*     multi-valued attribute has been set for a class.

*  Parameters:
*      attr
*         The name of the attribute to be tested, as it appears in the function
*         name (e.g. LabelAt in "astTestLabelAt").
*      assign
*         An expression that evaluates to 0 or 1, to be used as the returned
*         value. This can use the string "axis" to represent the zero-based
*         index of the value within the attribute.
*      nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_TEST(attr,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static int Test##attr( AstPlot *this, int axis, int *status ) { \
   int result;                   /* Value to return */ \
\
/* Initialise */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= ( nval ? nval : astGetNin( this ) ) ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astTest" #attr, astGetClass( this ), \
                axis + 1, ( nval ? nval : astGetNin( this ) ) ); \
\
/* Assign the result value. */ \
   } else { \
      result = (assign); \
   } \
\
/* Check for errors and clear the result if necessary. */ \
   if ( !astOK ) result = 0; \
\
/* Return the result. */ \
   return result; \
} \
/* External interface. */ \
/* ------------------- */ \
int astTest##attr##_( AstPlot *this, int axis, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return 0; \
\
/* Invoke the required method via the virtual function table. */ \
   return (**astMEMBER(this,Plot,Test##attr))( this, axis, status ); \
}

/*
*
*  Name:
*     MAKE_GET3

*  Purpose:
*     Implement a method to get a single value in a multi-valued attribute.

*  Type:
*     Private macro.

*  Synopsis:
*     MAKE_GET3(attr,attr,type,bad_value,assign,nval)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static <Type> Get<Attribute>( AstPlot *this, int axis )
*
*     which implements a method for getting a single value from a specified
*     multi-valued attribute for an axis of a Plot. Note, no public
*     interface function is created.
*
*     The value returned is the value which would actually be used if
*     astGrid was called with the current set of Plot attributes. This
*     includes calculating any dynamic defaults which would be used, and is
*     consequently rather slow.

*  Parameters:
*     attr
*        The name of the attribute whose value is to be obtained, as it
*        appears in the function name (e.g. Label in "astGetLabel"). The
*        string "Used" is added on to the front of the supplied value.
*     type
*        The C type of the attribute.
*     bad_value
*        A constant value to return if the global error status is set, or if
*        the function fails.
*     assign
*        An expression that evaluates to the value to be returned. This can
*        use the string "axis" to represent the zero-based value index.
*     nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*
*/

/* Define the macro. */
#define MAKE_GET3(attr,type,bad_value,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static type GetUsed##attr( AstPlot *, int, int *status ); \
static type GetUsed##attr( AstPlot *this, int axis, int *status ) { \
   type result;                  /* Result to be returned */ \
\
/* Initialise */ \
   result = (bad_value); \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= ( nval ? nval : astGetNin( this ) ) ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astGetUsed" #attr, astGetClass( this ), \
                axis + 1, ( nval ? nval : astGetNin( this ) ) ); \
\
/* If the attribute is set, use its normal accessor. */\
   } else if( astTest##attr( this, axis ) ) {\
      result = astGet##attr( this, axis );\
\
/* Otherwise, re-calculate dynamic defaults by going through the motions of \
   drawing the grid. Nothing is actually drawn because we set the protected \
   attribute Ink to zero first. The calculated values are stored in the \
   Plot structure. */ \
   } else { \
      astSetInk( this, 0 ); \
      astGrid( this ); \
      astClearInk( this ); \
\
/* Assign the result value. */ \
      result = (assign); \
   } \
\
/* Check for errors and clear the result if necessary. */ \
   if ( !astOK ) result = (bad_value); \
\
/* Return the result. */ \
   return result; \
}

/*
*
*  Name:
*     MAKE_SET3

*  Purpose:
*     Implement a method to set a single value in a multi-valued attribute
*     for a Plot. This is identical to MAKE_SET except that no external
*     interface function is created.

*  Type:
*     Private macro.

*  Synopsis:
*     MAKE_SET3(attr,type,component,assign,nval)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void Set<Attribute>( AstPlot *this, int axis, <Type> value )
*
*     which implements a method for setting a single value in a specified
*     multi-valued attribute for a Plot.

*  Parameters:
 *     attr
*        The name of the attribute whose value is to be obtained, as it
*        appears in the function name (e.g. Label in "astSetLabel"). The
*        string "Used" is added on to the front of the supplied value.
*      type
*         The C type of the attribute.
*      component
*         The name of the class structure component that holds the attribute
*         value.
*      assign
*         An expression that evaluates to the value to be assigned to the
*         component.
*      nval
*        Specifies the number of values in the multi-valued attribute. The
*        "axis" values supplied to the created function should be in the
*        range zero to (nval - 1). If a value of 0 is supplied, the
*        value of the Plot's Nin attribute is used instead.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_SET3(attr,type,component,assign,nval) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void SetUsed##attr( AstPlot *, int, type, int *status ); \
static void SetUsed##attr( AstPlot *this, int axis, type value, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Validate the axis index. */ \
   if( axis < 0 || axis >= ( nval ? nval : astGetNin( this ) ) ){ \
      astError( AST__AXIIN, "%s(%s): Index (%d) is invalid for attribute " \
                #attr " - it should be in the range 1 to %d.", status, \
                "astSetUsed" #attr, astGetClass( this ), \
                axis + 1, ( nval ? nval : astGetNin( this ) ) ); \
\
/* Store the new value in the structure component. */ \
   } else { \
      this->component[ axis ] = (assign); \
   } \
}

/*
*+
*  Name:
*     MAKE_GET2

*  Purpose:
*     Implement a method to get an attribute value for a class.

*  Type:
*     Protected macro.

*  Synopsis:
*     MAKE_GET2(class,attr,type,bad_value,assign)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static <Type> GetUsed<Attr>( AstPlot *this )
*
*     which implement a method for getting a specified attribute value for a
*     class. Note, no public interface function is created.
*
*     The value returned is the value which would actually be used if
*     astGrid was called with the current set of Plot attributes. This
*     includes calculating any dynamic defaults which would be used, and is
*     consequently rather slow.

*  Parameters:
*     class
*        The name (not the type) of the class to which the attribute belongs.
*     attr
*        The name of the attribute whose value is to be obtained, as it
*        appears in the function name (e.g. Label in "astGetLabel"). The
*        string "Used" is added on to the front of the supplied value.
*     type
*        The C type of the attribute.
*     bad_value
*        A constant value to return if the global error status is set, or if
*        the function fails.
*     assign
*        An expression that evaluates to the value to be returned.

*  Notes:
*     -  To avoid problems with some compilers, you should not leave any white
*     space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_GET2(class,attr,type,bad_value,assign) \
\
/* Private member function. */ \
/* ------------------------ */ \
static type GetUsed##attr( Ast##class *, int *status ); \
static type GetUsed##attr( Ast##class *this, int *status ) { \
   type result;               /* Result to be returned */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return (bad_value); \
\
/* If the attribute is set, use its normal accessor. */\
   if( astTest##attr( this ) ) {\
      result = astGet##attr( this );\
\
/* Otherwise, re-calculate dynamic defaults by going through the motions of \
   drawing the grid. Nothing is actually drawn because we set the protected \
   attribute Ink to zero first. The calculated values are stored in the \
   Plot structure. */ \
   } else { \
      astSetInk( this, 0 ); \
      astGrid( this ); \
      astClearInk( this ); \
\
/* Assign the result value. */ \
      result = (assign); \
   } \
\
/* Check for errors and clear the result if necessary. */ \
   if ( !astOK ) result = (bad_value); \
\
/* Return the result. */ \
   return result; \
}

/*
*+
*  Name:
*     MAKE_SET2

*  Purpose:
*     Implement a method to set an attribute value for a class. This
*     is identical to astMAKE_SET except that it does not create an
*     external interface function, and it does create a private function
*     prototype.

*  Type:
*     Protected macro.

*  Synopsis:
*     MAKE_SET2(class,attr,type,component,assign)

*  Class Membership:
*     Defined by the Plot class.

*  Description:
*     This macro expands to an implementation of a private member function of
*     the form:
*
*        static void SetUsed<Attr>( AstPlot *this, <Type> value )
*
*     which implements a method for setting a specified attribute value for a
*     class.

*  Parameters:
*      class
*         The name (not the type) of the class to which the attribute belongs.
*      attr
*         The name of the attribute to be set, as it appears in the function
*         name (e.g. Label in "astSetLabel"). The string "Used" is added
*         to the front.
*      type
*         The C type of the attribute.
*      component
*         The name of the class structure component that holds the attribute
*         value.
*      assign
*         An expression that evaluates to the value to be assigned to the
*         component.

*  Notes:
*     - To avoid problems with some compilers, you should not leave
*     any white space around the macro arguments.
*-
*/

/* Define the macro. */
#define MAKE_SET2(class,attr,type,component,assign) \
\
/* Private member function. */ \
/* ------------------------ */ \
static void SetUsed##attr( Ast##class *, type, int *status ); \
static void SetUsed##attr( Ast##class *this, type value, int *status ) { \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Store the new value in the structure component. */ \
   this->component = (assign); \
}


/* Header files. */
/* ============= */
/* Interface definitions. */
/* ---------------------- */
#include "channel.h"             /* I/O channels */
#include "cmpmap.h"              /* Compound mapping class */

#include "globals.h"             /* Thread-safe global data access */
#include "error.h"               /* Error reporting facilities */
#include "frame.h"               /* Coordinate frame descriptions */
#include "frameset.h"            /* Parent FrameSet class */
#include "grf.h"                 /* Low-level graphics interface */
#include "memory.h"              /* Memory allocation facilities */
#include "object.h"              /* Base Object class */
#include "plot.h"                /* Interface definition for this class */
#include "pointset.h"            /* Class holding lists of positions */
#include "keymap.h"              /* Hash maps */
#include "skyaxis.h"             /* Sky coordinate axes */
#include "skyframe.h"            /* Sky coordinate frames */
#include "winmap.h"              /* Scale and shift mappings */
#include "mathmap.h"             /* Algebraic mappings */
#include "wcsmap.h"              /* FITS-WCS projectsions */
#include "unitmap.h"             /* Unit mappings */
#include "permmap.h"             /* Axis permutations */
#include "region.h"              /* Frame regions */
#include "globals.h"             /* Thread-safe global data access */


/* Error code definitions. */
/* ----------------------- */
#include "ast_err.h"             /* AST error codes */

/* C header files. */
/* --------------- */
#include <ctype.h>
#include <float.h>
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>

/* Module Type Definitions */
/* ======================= */
typedef struct LabelList {
   double index;
   char *text;
   double x;
   double y;
   char *just;
   double upx;
   double upy;
   double val;
   int priority;
   const char *atext;
   int saved_prio;
} LabelList;

/* Structure to hold static data used internally within the Crv function. */
typedef struct CrvStatics {
   double *pdl2;   /* Pointer to next squared segment length */
   double *pdx;    /* Pointer to next segment X increment */
   double *pdy;    /* Pointer to next segment Y increment */
   double cosang;  /* Cosine of angle between adjacent segments */
   double d0;      /* Distance to start of first sub-segment */
   double delta;   /* Distance between adjacent sub-segments */
   double dl;      /* Segment length in graphics coordinates */
   double dll;     /* Segment length for previous segment */
   double last_x;  /* Graphics X at the end of the previous segment */
   double last_y;  /* Graphics Y at the end of the previous segment */
   double limit2;  /* Shortest acceptable squared segment length */
   double t1;      /* Increment in X */
   double t2;      /* Increment in Y */
   double t3;      /* Squared segment length */
   double vx;      /* X component of unit vector for current segment */
   double vxl;     /* X component of unit vector for previous segment */
   double vy;      /* Y component of unit vector for current segment */
   double vyl;     /* Y component of unit vector for previous segment */
   int *seg0;      /* Pointer to current segment OK flag */
   int *segm;      /* Pointer to previous segment OK flag */
   int *segp;      /* Pointer to next segment OK flag */
   int all_bad;    /* Are all supplied positions bad or clipped?  */
   int el;         /* Total sub-segment count */
   int j;          /* Sub-segment index */
   int last_ok;    /* Was the previous position defined? */
   int nel;        /* Total number of sub-segments */
   int nlong;      /* No.of segments longer than limit2 */
   int nseg;       /* Number of segments being sub-divided */
   int nshort;     /* No.of segments shorter than limit2 */

#ifdef CRV_TRACE
   int levels[100];
#endif

} CrvStatics;

/* Structure to hold static data used internally within the Crv function. */
typedef struct GetTicksStatics {
   AstFrame *frame;          /* Pointer to the current Frame */
   AstMapping *map;          /* Pointer to Base->Current Mapping */
   AstPointSet *pset;        /* Pointer to a PointSet holding physical coords */
   double **ptr;             /* Pointer to physical coordinate values */
   double defgaps[ 2 ];      /* Initial test gaps for each axis */
   double typval[ 2 ];       /* Typical value on each axis */
   double width[ 2 ];        /* Range of used axis values */
   int maxticks;             /* Max. number of ticks on each axis */
   int mintick;              /* Min. number of ticks on each axis */
   int ngood[ 2 ];           /* No. of good physical values on each axis */
   int bad;                  /* Were any bad pixels found? */
} GetTicksStatics;

/* Structure to hold static data used internally within the EdgeCrossings
   function. */
typedef struct EdgeCrossingsStatics {
   AstFrame *frame;          /* Pointer to current Frame in Plot */
   AstPointSet *pset1;       /* Graphics cooords at edge samples */
   AstPointSet *pset2;       /* Physical cooords at edge samples */
   AstPointSet *pset4;       /* Graphics cooords at offset edge samples */
   double **ptr1;            /* Pointer to graphics coord. data */
   double **ptr2;            /* Pointer to physical coord. data */
   double **ptr4;            /* Pointer to graphics coord. data */
   double edgehi;            /* High bound on varying graphics axis */
   double edgelo;            /* Low bound on varying graphics axis */
   double edgeval;           /* Constant graphics axis value along edge */
   double limit;             /* Three times the RMS step size */
   int dim;                  /* Extended number of samples */
   int edgeax;               /* Graphics axis to which edgeval refers */
   int paxis;                /* Axis used in first invocation */
   int pedge;                /* Edge used in first invocation */
} EdgeCrossingsStatics;


/* Structure to hold static data used internally within the Map1
   function. */
typedef struct Map1Statics {
   AstPointSet *pset1;       /* PointSet holding physical coords */
   AstPointSet *pset2;       /* PointSet holding graphics coords */
   double **ptr1;            /* Pointer to physical coord data */
   double *pax;              /* Pointer to start of axis data */
   double *ptr2[ 2 ];        /* Pointers to graphics coord data */
   double *work1;            /* Pointer to work space */
   double *work2;            /* Pointer to work space */
   double axorig;            /* Distance offset */
   double axscale;           /* Distance scale */
   int neg;                  /* Negate axis values? */
   int nl;                   /* No. of points in pset1 and pset2 */
} Map1Statics;

/* Structure to hold static data used internally within the Map2
   function. */
typedef struct Map2Statics {
   AstPointSet *pset1;       /* PointSet holding graphics coords */
   AstPointSet *pset2;       /* PointSet holding physical coords */
   double **ptr2;            /* Pointer to physical coord data */
   double *ptr1[ 2 ];        /* Pointers to graphics coord data */
   int nl;                   /* No. of points in pset1 and pset2 */
} Map2Statics;

/* Structure to hold static data used internally within the Map3
   function. */
typedef struct Map3Statics {
   AstPointSet *pset1;       /* PointSet holding physical coords */
   AstPointSet *pset2;       /* PointSet holding graphics coords */
   double **ptr1;            /* Pointer to physical coord data */
   double *ptr2[ 2 ];        /* Pointers to graphics coord data */
   int nc;                   /* No. of physical axes */
   int nl;                   /* No. of points in pset1 and pset2 */
   double *pos;              /* Pointer to memory for a single position */
} Map3Statics;

/* Structure to hold static data used internally within the Map4
   function. */
typedef struct Map4Statics {
   AstPointSet *pset1;       /* PointSet holding distances */
   AstPointSet *pset2;       /* PointSet holding physical coords */
   AstPointSet *pset3;       /* PointSet holding graphics coords */
   int nl;                   /* No. of points in pset1 and pset2 */
} Map4Statics;

/* Structure to hold static data used internally within the Map5
   function. */
typedef struct Map5Statics {
   AstPointSet *pset1;       /* PointSet holding physical coords */
   AstPointSet *pset2;       /* PointSet holding graphics coords */
   double **ptr1;            /* Pointer to physical coord data */
   double *ptr2[ 2 ];        /* Pointers to graphics coord data */
   int nl;                   /* No. of points in pset1 and pset2 */
} Map5Statics;

/* Structure to hold information about tick marks for a single axis. */
typedef struct TickInfo{
   int nmajor;               /* No. of major tick marks */
   int nminor;               /* No. of minor tick marks */
   double *ticks;            /* Pointer to array of major tick mark values */
   double *minticks;         /* Pointer to array of minor tick mark values */
   char **labels;            /* Pointer to array of major tick mark labels */
   double *start;            /* Start pos'n on other axis for each curve section */
   double *length;           /* Length on other axis of each curve section */
   int nsect;                /* No. of sections in curve */
   char *fmt;                /* Pointer to format string used to create labels */
   double gap;               /* The gap between major ticks */
} TickInfo;

/* Module Variables. */
/* ================= */

/* Address of this static variable is used as a unique identifier for
   member of this class. */
static int class_check;

/* Pointers to parent class methods which are extended by this class. */
static void (* parent_removeframe)( AstFrameSet *, int, int * );
static AstPointSet *(* parent_transform)( AstMapping *, AstPointSet *, int,
                                          AstPointSet *, int * );
static const char *(* parent_getattrib)( AstObject *, const char *, int * );
static int (* parent_testattrib)( AstObject *, const char *, int * );
static void (* parent_clearattrib)( AstObject *, const char *, int * );
static void (* parent_setattrib)( AstObject *, const char *, int * );

#if defined(THREAD_SAFE)
static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
#endif

/* Strings giving the label for the graphics items corresponding to
   AST__BORDER_ID, AST__GRIDLINE_ID, etc. */
static char *GrfLabels = "Border Curves Title Markers Strings Axis1 Axis2 Axis3 "
                         "NumLab1 NumLab2 NumLab3 TextLab1 TextLab2 TextLab3 "
                         "Ticks1 Ticks2 Ticks3 Grid1 Grid2 Grid3 Axes NumLab "
                         "TextLab Grid Ticks";

/* Text values used to represent edges externally. */
static const char *xedge[4] = { "left", "top", "right", "bottom" };

/* Text values used to represent Labelling externally. */
static const char *xlbling[2] = { "exterior", "interior" };

/* Text values used to represent TextGapType externally. */
static const char *xtgaptype[2] = { "box", "plot" };

/* Define macros for accessing each item of thread specific global data. */
#ifdef THREAD_SAFE

/* Define how to initialise thread-specific globals. */
#define GLOBAL_inits \
   globals->Class_Init = 0; \
   globals->GrfAttrs_nesting_t = 0; \
   globals->Crv_nent_t = 0; \
   globals->Box_lbnd_t[ 0 ] = FLT_MAX; \
   globals->Box_ubnd_t[ 0 ] = FLT_MIN; \
   globals->Boxp_lbnd_t[ 0 ] = FLT_MAX; \
   globals->Boxp_ubnd_t[ 0 ] = FLT_MIN; \
   globals->Box_lbnd_t[ 1 ] = FLT_MAX; \
   globals->Box_ubnd_t[ 1 ] = FLT_MIN; \
   globals->Boxp_lbnd_t[ 1 ] = FLT_MAX; \
   globals->Boxp_ubnd_t[ 1 ] = FLT_MIN; \
   globals->Boxp_freeze_t = 0; \
   globals->Map1_plot_t = NULL; \
   globals->Map1_map_t = NULL; \
   globals->Map1_frame_t = NULL; \
   globals->Map1_origin_t = NULL; \
   globals->Map1_statics_t = NULL; \
   globals->Map2_plot_t = NULL; \
   globals->Map2_map_t = NULL; \
   globals->Map2_statics_t = NULL; \
   globals->Map3_plot_t = NULL; \
   globals->Map3_map_t = NULL; \
   globals->Map3_frame_t = NULL; \
   globals->Map3_origin_t = NULL; \
   globals->Map3_end_t = NULL; \
   globals->Map3_statics_t = NULL; \
   globals->Map4_plot_t = NULL; \
   globals->Map4_map_t = NULL; \
   globals->Map4_umap_t = NULL; \
   globals->Map4_statics_t = NULL; \
   globals->Map5_plot_t = NULL; \
   globals->Map5_region_t = NULL; \
   globals->Map5_map_t = NULL; \
   globals->Map5_statics_t = NULL; \
   globals->Poly_n_t = 0; \
   globals->Poly_x_t = NULL; \
   globals->Poly_y_t = NULL; \
   globals->Poly_npoly_t = 0; \
   globals->Poly_np_t = NULL; \
   globals->Poly_xp_t = NULL; \
   globals->Poly_yp_t = NULL; \
   globals->Curve_data_t.nbrk = -1; \
   globals->GetAttrib_Buff[ 0 ] = 0; \
   globals->SplitValue_Buff[ 0 ] = 0; \
   globals->StripEscapes_Buff[ 0 ] = 0; \
   globals->Grf_chv_t = AST__BAD; \
   globals->Grf_chh_t = AST__BAD; \
   globals->Grf_alpha_t = 0.0; \
   globals->Grf_beta_t = 0.0;

/* Create the function that initialises global data for this module. */
astMAKE_INITGLOBALS(Plot)

/* Define macros for accessing each item of thread specific global data. */
#define class_init astGLOBAL(Plot,Class_Init)
#define class_vtab astGLOBAL(Plot,Class_Vtab)
#define grfattrs_nesting astGLOBAL(Plot,GrfAttrs_nesting_t)
#define grfattrs_attrs  astGLOBAL(Plot,GrfAttrs_attrs_t)
#define Crv_limit 	astGLOBAL(Plot,Crv_limit_t)
#define Crv_scerr 	astGLOBAL(Plot,Crv_scerr_t)
#define Crv_tol 	astGLOBAL(Plot,Crv_tol_t)
#define Crv_ux0 	astGLOBAL(Plot,Crv_ux0_t)
#define Crv_uy0 	astGLOBAL(Plot,Crv_uy0_t)
#define Crv_vxl 	astGLOBAL(Plot,Crv_vxl_t)
#define Crv_vyl 	astGLOBAL(Plot,Crv_vyl_t)
#define Crv_xhi 	astGLOBAL(Plot,Crv_xhi_t)
#define Crv_xl 		astGLOBAL(Plot,Crv_xl_t)
#define Crv_xlo 	astGLOBAL(Plot,Crv_xlo_t)
#define Crv_yhi 	astGLOBAL(Plot,Crv_yhi_t)
#define Crv_yl 		astGLOBAL(Plot,Crv_yl_t)
#define Crv_ylo 	astGLOBAL(Plot,Crv_ylo_t)
#define Crv_vxbrk 	astGLOBAL(Plot,Crv_vxbrk_t)
#define Crv_vybrk 	astGLOBAL(Plot,Crv_vybrk_t)
#define Crv_xbrk 	astGLOBAL(Plot,Crv_xbrk_t)
#define Crv_ybrk 	astGLOBAL(Plot,Crv_ybrk_t)
#define Crv_len 	astGLOBAL(Plot,Crv_len_t)
#define Crv_ink 	astGLOBAL(Plot,Crv_ink_t)
#define Crv_nbrk 	astGLOBAL(Plot,Crv_nbrk_t)
#define Crv_nent 	astGLOBAL(Plot,Crv_nent_t)
#define Crv_out 	astGLOBAL(Plot,Crv_out_t)
#define Crv_clip 	astGLOBAL(Plot,Crv_clip_t)
#define Crv_map		astGLOBAL(Plot,Crv_map_t)
#define Box_lbnd 	astGLOBAL(Plot,Box_lbnd_t)
#define Box_ubnd 	astGLOBAL(Plot,Box_ubnd_t)
#define Boxp_lbnd 	astGLOBAL(Plot,Boxp_lbnd_t)
#define Boxp_ubnd 	astGLOBAL(Plot,Boxp_ubnd_t)
#define Boxp_freeze 	astGLOBAL(Plot,Boxp_freeze_t)
#define Poly_x 		astGLOBAL(Plot,Poly_x_t)
#define Poly_y 		astGLOBAL(Plot,Poly_y_t)
#define Poly_n 		astGLOBAL(Plot,Poly_n_t)
#define Poly_xp 	astGLOBAL(Plot,Poly_xp_t)
#define Poly_yp 	astGLOBAL(Plot,Poly_yp_t)
#define Poly_np 	astGLOBAL(Plot,Poly_np_t)
#define Poly_npoly      astGLOBAL(Plot,Poly_npoly_t)
#define Map1_ncoord 	astGLOBAL(Plot,Map1_ncoord_t)
#define Map1_plot 	astGLOBAL(Plot,Map1_plot_t)
#define Map1_map 	astGLOBAL(Plot,Map1_map_t)
#define Map1_frame 	astGLOBAL(Plot,Map1_frame_t)
#define Map1_origin 	astGLOBAL(Plot,Map1_origin_t)
#define Map1_length 	astGLOBAL(Plot,Map1_length_t)
#define Map1_axis 	astGLOBAL(Plot,Map1_axis_t)
#define Map1_statics 	astGLOBAL(Plot,Map1_statics_t)
#define Map1_norm 	astGLOBAL(Plot,Map1_norm_t)
#define Map1_log 	astGLOBAL(Plot,Map1_log_t)
#define Map2_ncoord 	astGLOBAL(Plot,Map2_ncoord_t)
#define Map2_plot 	astGLOBAL(Plot,Map2_plot_t)
#define Map2_map 	astGLOBAL(Plot,Map2_map_t)
#define Map2_x0 	astGLOBAL(Plot,Map2_x0_t)
#define Map2_y0 	astGLOBAL(Plot,Map2_y0_t)
#define Map2_deltax 	astGLOBAL(Plot,Map2_deltax_t)
#define Map2_deltay 	astGLOBAL(Plot,Map2_deltay_t)
#define Map2_statics 	astGLOBAL(Plot,Map1_statics_t)
#define Map3_ncoord 	astGLOBAL(Plot,Map3_ncoord_t)
#define Map3_plot 	astGLOBAL(Plot,Map3_plot_t)
#define Map3_map 	astGLOBAL(Plot,Map3_map_t)
#define Map3_frame 	astGLOBAL(Plot,Map3_frame_t)
#define Map3_origin 	astGLOBAL(Plot,Map3_origin_t)
#define Map3_end 	astGLOBAL(Plot,Map3_end_t)
#define Map3_scale 	astGLOBAL(Plot,Map3_scale_t)
#define Map3_statics 	astGLOBAL(Plot,Map3_statics_t)
#define Map4_ncoord 	astGLOBAL(Plot,Map4_ncoord_t)
#define Map4_plot 	astGLOBAL(Plot,Map4_plot_t)
#define Map4_map 	astGLOBAL(Plot,Map4_map_t)
#define Map4_umap 	astGLOBAL(Plot,Map4_umap_t)
#define Map4_statics 	astGLOBAL(Plot,Map4_statics_t)
#define Map5_plot 	astGLOBAL(Plot,Map5_plot_t)
#define Map5_region 	astGLOBAL(Plot,Map5_region_t)
#define Map5_map 	astGLOBAL(Plot,Map5_map_t)
#define Map5_ncoord 	astGLOBAL(Plot,Map5_ncoord_t)
#define Map5_statics 	astGLOBAL(Plot,Map5_statics_t)
#define Curve_data 	astGLOBAL(Plot,Curve_data_t)
#define getattrib_buff  astGLOBAL(Plot,GetAttrib_Buff)
#define splitvalue_buff astGLOBAL(Plot,SplitValue_Buff)
#define stripescapes_buff astGLOBAL(Plot,StripEscapes_Buff)
#define Grf_chv 	astGLOBAL(Plot,Grf_chv_t)
#define Grf_chh 	astGLOBAL(Plot,Grf_chh_t)
#define Grf_alpha 	astGLOBAL(Plot,Grf_alpha_t)
#define Grf_beta 	astGLOBAL(Plot,Grf_beta_t)

static pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_MUTEX2 pthread_mutex_lock( &mutex2 );
#define UNLOCK_MUTEX2 pthread_mutex_unlock( &mutex2 );

/* If thread safety is not needed, declare and initialise globals at static
   variables. */
#else

/* Variables used within astGrfAttrs_ */
static double grfattrs_attrs[ GRF__NATTR ]; /* Saved attribute values */
static int grfattrs_nesting = 0;            /* Nesting level. */

/* Variables used to pass information to the curve drawing functions. See
   the prologues of functions Crv and CrvLine for details. */
static double Crv_limit;
static double Crv_scerr;
static double Crv_tol;
static double Crv_ux0;
static double Crv_uy0;
static double Crv_vxl;
static double Crv_vyl;
static double Crv_xhi;
static double Crv_xl;
static double Crv_xlo;
static double Crv_yhi;
static double Crv_yl;
static double Crv_ylo;
static float *Crv_vxbrk;
static float *Crv_vybrk;
static float *Crv_xbrk;
static float *Crv_ybrk;
static float Crv_len;
static int Crv_ink;
static int Crv_nbrk;
static int Crv_nent = 0;
static int Crv_out;
static int Crv_clip;
static void (*Crv_map)( int, double *, double *, double *, const char *, const char *, int * );

/* A cache of information calculated by the grf module. */
static double Grf_chv = AST__BAD;
static double Grf_chh = AST__BAD;
static float Grf_alpha = 0.0;
static float Grf_beta = 0.0;

/* The lower and upper bounds of the graphics coordinates enclosing all
   lines and numerical labels drawn by astGrid. */
static float Box_lbnd[ 2 ] = {FLT_MAX, FLT_MAX };
static float Box_ubnd[ 2 ] = {FLT_MIN, FLT_MIN };

/* The lower and upper bounds of the graphics coordinates enclosing all
   drawn graphics primatives, maintained by functions GLine, GMark and
   DrawText. */
static float Boxp_lbnd[ 2 ] = {FLT_MAX, FLT_MAX };
static float Boxp_ubnd[ 2 ] = {FLT_MIN, FLT_MIN };
static int Boxp_freeze = 0;

/* Variables used to stored buffered poly lines (see functions Opoly, Bpoly
   and Apoly). */
static float        *Poly_x = NULL;
static float        *Poly_y = NULL;
static int           Poly_n = 0;
static float       **Poly_xp = NULL;
static float       **Poly_yp = NULL;
static int          *Poly_np = NULL;
static int           Poly_npoly = 0;

/* Variables used by function Map1. See the prologue of Map1 for details. */
static int           Map1_ncoord;
static AstPlot      *Map1_plot = NULL;
static AstMapping   *Map1_map = NULL;
static AstFrame     *Map1_frame = NULL;
static const double *Map1_origin = NULL;
static double        Map1_length;
static void         *Map1_statics = NULL;
static int           Map1_axis;
static int           Map1_norm;
static int           Map1_log;

/* Variables used by function Map2. See the prologue of Map2 for details. */
static int           Map2_ncoord;
static AstPlot      *Map2_plot = NULL;
static AstMapping   *Map2_map = NULL;
static double        Map2_x0;
static double        Map2_y0;
static double        Map2_deltax;
static double        Map2_deltay;
static void         *Map2_statics = NULL;

/* Variables used by function Map3. See the prologue of Map3 for details. */
static int           Map3_ncoord;
static AstPlot      *Map3_plot = NULL;
static AstMapping   *Map3_map = NULL;
static AstFrame     *Map3_frame = NULL;
static const double *Map3_origin = NULL;
static const double *Map3_end = NULL;
static double        Map3_scale;
static void         *Map3_statics = NULL;

/* Variables used by function Map4. See the prologue of Map4 for details. */
static int           Map4_ncoord;
static AstPlot      *Map4_plot = NULL;
static AstMapping   *Map4_map = NULL;
static AstMapping   *Map4_umap = NULL;
static void         *Map4_statics = NULL;

/* Variables used by function Map5. See the prologue of Map5 for details. */
static AstPlot      *Map5_plot = NULL;
static AstMapping   *Map5_map = NULL;
static AstRegion    *Map5_region = NULL;
static void         *Map5_statics = NULL;
static int           Map5_ncoord;

/* A structure which stores information about the breaks in the last curve
   drawn using the public methods "astGridLine" and "astCurve". */
static AstPlotCurveData Curve_data;

/* Buffers for strings returned by various functions. */
static char splitvalue_buff[ 200 ];
static char stripescapes_buff[ AST__PLOT_STRIPESCAPES_BUFF_LEN + 1 ];
static char getattrib_buff[ 200 ];


/* Define the class virtual function table and its initialisation flag
   as static variables. */
static AstPlotVtab class_vtab;   /* Virtual function table */
static int class_init = 0;       /* Virtual function table initialised? */

#define LOCK_MUTEX2
#define UNLOCK_MUTEX2

#endif

/* Macro to reset the cache of values caclulated by the grf module. */
#define RESET_GRF \
   Grf_chh = AST__BAD; \
   Grf_chv = AST__BAD; \
   Grf_alpha = 0.0; \
   Grf_beta = 0.0;


/* Prototypes for Private Member Functions. */
/* ======================================== */

static double GetTol( AstPlot *, int * );
static int TestTol( AstPlot *, int * );
static void ClearTol( AstPlot *, int * );
static void SetTol( AstPlot *, double, int * );

static int GetGrid( AstPlot *, int * );
static int TestGrid( AstPlot *, int * );
static void ClearGrid( AstPlot *, int * );
static void SetGrid( AstPlot *, int, int * );

static int GetTickAll( AstPlot *, int * );
static int TestTickAll( AstPlot *, int * );
static void ClearTickAll( AstPlot *, int * );
static void SetTickAll( AstPlot *, int, int * );

static int GetForceExterior( AstPlot *, int * );
static int TestForceExterior( AstPlot *, int * );
static void ClearForceExterior( AstPlot *, int * );
static void SetForceExterior( AstPlot *, int, int * );

static int GetBorder( AstPlot *, int * );
static int TestBorder( AstPlot *, int * );
static void ClearBorder( AstPlot *, int * );
static void SetBorder( AstPlot *, int, int * );

static int GetInvisible( AstPlot *, int * );
static int TestInvisible( AstPlot *, int * );
static void ClearInvisible( AstPlot *, int * );
static void SetInvisible( AstPlot *, int, int * );

static int GetInk( AstPlot *, int * );
static int TestInk( AstPlot *, int * );
static void ClearInk( AstPlot *, int * );
static void SetInk( AstPlot *, int, int * );

static int GetClipOp( AstPlot *, int * );
static int TestClipOp( AstPlot *, int * );
static void ClearClipOp( AstPlot *, int * );
static void SetClipOp( AstPlot *, int, int * );

static int GetClip( AstPlot *, int * );
static int TestClip( AstPlot *, int * );
static void ClearClip( AstPlot *, int * );
static void SetClip( AstPlot *, int, int * );

static int GetGrf( AstPlot *, int * );
static int TestGrf( AstPlot *, int * );
static void ClearGrf( AstPlot *, int * );
static void SetGrf( AstPlot *, int, int * );

static int GetDrawTitle( AstPlot *, int * );
static int TestDrawTitle( AstPlot *, int * );
static void ClearDrawTitle( AstPlot *, int * );
static void SetDrawTitle( AstPlot *, int, int * );

static int GetDrawAxes( AstPlot *, int, int * );
static int TestDrawAxes( AstPlot *, int, int * );
static void ClearDrawAxes( AstPlot *, int, int * );
static void SetDrawAxes( AstPlot *, int, int, int * );

static int GetAbbrev( AstPlot *, int, int * );
static int TestAbbrev( AstPlot *, int, int * );
static void ClearAbbrev( AstPlot *, int, int * );
static void SetAbbrev( AstPlot *, int, int, int * );

static int GetEscape( AstPlot *, int * );
static int TestEscape( AstPlot *, int * );
static void ClearEscape( AstPlot *, int * );
static void SetEscape( AstPlot *, int, int * );

static double GetLabelAt( AstPlot *, int, int * );
static int TestLabelAt( AstPlot *, int, int * );
static void ClearLabelAt( AstPlot *, int, int * );
static void SetLabelAt( AstPlot *, int, double, int * );

static double GetNumLabGap( AstPlot *, int, int * );
static int TestNumLabGap( AstPlot *, int, int * );
static void ClearNumLabGap( AstPlot *, int, int * );
static void SetNumLabGap( AstPlot *, int, double, int * );

static double GetTextLabGap( AstPlot *, int, int * );
static int TestTextLabGap( AstPlot *, int, int * );
static void ClearTextLabGap( AstPlot *, int, int * );
static void SetTextLabGap( AstPlot *, int, double, int * );

static double GetCentre( AstPlot *, int, int * );
static int TestCentre( AstPlot *, int, int * );
static void ClearCentre( AstPlot *, int, int * );
static void SetCentre( AstPlot *, int, double, int * );

static double GetGap( AstPlot *, int, int * );
static int TestGap( AstPlot *, int, int * );
static void ClearGap( AstPlot *, int, int * );
static void SetGap( AstPlot *, int, double, int * );

static int GetLabelling( AstPlot *, int * );
static int TestLabelling( AstPlot *, int * );
static void ClearLabelling( AstPlot *, int * );
static void SetLabelling( AstPlot *, int, int * );

static int GetTextGapType( AstPlot *, int * );
static int TestTextGapType( AstPlot *, int * );
static void ClearTextGapType( AstPlot *, int * );
static void SetTextGapType( AstPlot *, int, int * );

static double GetMajTickLen( AstPlot *, int, int * );
static int TestMajTickLen( AstPlot *, int, int * );
static void ClearMajTickLen( AstPlot *, int, int * );
static void SetMajTickLen( AstPlot *, int, double, int * );

static double GetLogGap( AstPlot *, int, int * );
static int TestLogGap( AstPlot *, int, int * );
static void ClearLogGap( AstPlot *, int, int * );
static void SetLogGap( AstPlot *, int, double, int * );

static double GetTitleGap( AstPlot *, int * );
static int TestTitleGap( AstPlot *, int * );
static void ClearTitleGap( AstPlot *, int * );
static void SetTitleGap( AstPlot *, double, int * );

static double GetMinTickLen( AstPlot *, int, int * );
static int TestMinTickLen( AstPlot *, int, int * );
static void ClearMinTickLen( AstPlot *, int, int * );
static void SetMinTickLen( AstPlot *, int, double, int * );

static int GetEdge( AstPlot *, int, int * );
static int TestEdge( AstPlot *, int, int * );
static void ClearEdge( AstPlot *, int, int * );
static void SetEdge( AstPlot *, int, int, int * );

static int GetLabelUp( AstPlot *, int, int * );
static int TestLabelUp( AstPlot *, int, int * );
static void ClearLabelUp( AstPlot *, int, int * );
static void SetLabelUp( AstPlot *, int, int, int * );

static int GetLogPlot( AstPlot *, int, int * );
static int TestLogPlot( AstPlot *, int, int * );
static void ClearLogPlot( AstPlot *, int, int * );
static void SetLogPlot( AstPlot *, int, int, int * );

static int GetLogTicks( AstPlot *, int, int * );
static int TestLogTicks( AstPlot *, int, int * );
static void ClearLogTicks( AstPlot *, int, int * );
static void SetLogTicks( AstPlot *, int, int, int * );

static int GetLogLabel( AstPlot *, int, int * );
static int TestLogLabel( AstPlot *, int, int * );
static void ClearLogLabel( AstPlot *, int, int * );
static void SetLogLabel( AstPlot *, int, int, int * );

static int GetNumLab( AstPlot *, int, int * );
static int TestNumLab( AstPlot *, int, int * );
static void ClearNumLab( AstPlot *, int, int * );
static void SetNumLab( AstPlot *, int, int, int * );

static int GetMinTick( AstPlot *, int, int * );
static int TestMinTick( AstPlot *, int, int * );
static void ClearMinTick( AstPlot *, int, int * );
static void SetMinTick( AstPlot *, int, int, int * );

static int GetTextLab( AstPlot *, int, int * );
static int TestTextLab( AstPlot *, int, int * );
static void ClearTextLab( AstPlot *, int, int * );
static void SetTextLab( AstPlot *, int, int, int * );

static int GetLabelUnits( AstPlot *, int, int * );
static int TestLabelUnits( AstPlot *, int, int * );
static void ClearLabelUnits( AstPlot *, int, int * );
static void SetLabelUnits( AstPlot *, int, int, int * );

static int GetStyle( AstPlot *, int, int * );
static int TestStyle( AstPlot *, int, int * );
static void ClearStyle( AstPlot *, int, int * );
static void SetStyle( AstPlot *, int, int, int * );

static int GetFont( AstPlot *, int, int * );
static int TestFont( AstPlot *, int, int * );
static void ClearFont( AstPlot *, int, int * );
static void SetFont( AstPlot *, int, int, int * );

static int GetColour( AstPlot *, int, int * );
static int TestColour( AstPlot *, int, int * );
static void ClearColour( AstPlot *, int, int * );
static void SetColour( AstPlot *, int, int, int * );

static double GetWidth( AstPlot *, int, int * );
static int TestWidth( AstPlot *, int, int * );
static void ClearWidth( AstPlot *, int, int * );
static void SetWidth( AstPlot *, int, double, int * );

static double GetSize( AstPlot *, int, int * );
static int TestSize( AstPlot *, int, int * );
static void ClearSize( AstPlot *, int, int * );
static void SetSize( AstPlot *, int, double, int * );

static const char *GetAttrib( AstObject *, const char *, int * );
static int TestAttrib( AstObject *, const char *, int * );
static void ClearAttrib( AstObject *, const char *, int * );
static void SetAttrib( AstObject *, const char *, int * );

static AstFrameSet *Fset2D( AstFrameSet *, int, int * );
static AstKeyMap *GetGrfContext( AstPlot *, int * );
static AstPlotCurveData **CleanCdata( AstPlotCurveData **, int * );
static AstPlotCurveData **DrawGrid( AstPlot *, TickInfo **, int, const char *, const char *, int * );
static AstPointSet *DefGap( AstPlot *, double *, int *, double *, int *, const char *, const char *, int * );
static AstPointSet *GetDrawnTicks( AstPlot *, int, int, int * );
static AstPointSet *Trans( AstPlot *, AstFrame *, AstMapping *, AstPointSet *, int, AstPointSet *, int, const char *, const char *, int * );
static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
static TickInfo **CleanGrid( TickInfo **, int * );
static TickInfo **GridLines( AstPlot *, double *, double *, int *, const char *, const char *, int * );
static TickInfo *TickMarks( AstPlot *, int, double *, double *, int *, GetTicksStatics **, const char *, const char *, int * );
static char **CheckLabels2( AstPlot *, AstFrame *, int, double *, int, char **, double, int * );
static char *FindWord( char *, const char *, const char **, int * );
static char *GrfItem( int, const char *, int *, int * );
static const char *JustMB( AstPlot *, int, const char *, float *, float *, float, float, const char *, float, float, float, float, float *, float *, const char *, const char *, int * );
static const char *SplitValue( AstPlot *, const char *, int, int *, int * );
static double **MakeGrid( AstPlot *, AstFrame *, AstMapping *, int, int, double, double, double, double, int, AstPointSet **, AstPointSet**, int, const char *, const char *, int * );
static double GetTicks( AstPlot *, int, double *, double **, int *, double **, int *, int, int *, double *, GetTicksStatics **, const char *, const char *, int * );
static double GetUseSize( AstPlot *, int, int * );
static double GetUseWidth( AstPlot *, int, int * );
static double GoodGrid( AstPlot *, int *, AstPointSet **, AstPointSet **, const char *, const char *, int * );
static double Typical( int, double *, double, double, double *, int * );
static int Border( AstPlot *, int * );
static int Boundary( AstPlot *, const char *, const char *, int * );
static int BoxCheck( float *, float *, float *, float *, int * );
static int CGAttrWrapper( AstPlot *, int, double, double *, int, int * );
static int CGBBufWrapper( AstPlot *, int * );
static int CGCapWrapper( AstPlot *, int, int, int * );
static int CGEBufWrapper( AstPlot *, int * );
static int CGFlushWrapper( AstPlot *, int * );
static int CGLineWrapper( AstPlot *, int, const float *, const float *, int * );
static int CGMarkWrapper( AstPlot *, int, const float *, const float *, int, int * );
static int CGQchWrapper( AstPlot *, float *, float *, int * );
static int CGScalesWrapper( AstPlot *, float *, float *, int * );
static int CGTextWrapper( AstPlot *, const char *, float, float, const char *, float, float, int * );
static int CGTxExtWrapper( AstPlot *, const char *, float, float, const char *, float, float, float *, float *, int * );
static int CheckLabels( AstPlot *, AstFrame *, int, double *, int, int, char **, double, int * );
static int ChrLen( const char *, int * );
static int Compare_LL( const void *, const void * );
static int Compared( const void *, const void * );
static int CountGood( int, double *, int * );
static int Cross( float, float, float, float, float, float, float, float, int * );
static int CvBrk( AstPlot *, int, double *, double *, double *, int * );
static int DrawRegion( AstPlot *, AstFrame *, const char *, const char *, int * );
static int EdgeCrossings( AstPlot *, int, int, double, double *, double **, EdgeCrossingsStatics **, const char *, const char *, int * );
static int EdgeLabels( AstPlot *, int, TickInfo **, AstPlotCurveData **, int, const char *, const char *, int * );
static int FindDPTZ( AstFrame *, int, const char *, const char *, int *, int *, int * );
static int FindMajTicks( AstMapping *, AstFrame *, int, double, double, double , double *, int, double *, double **, int * );
static int FindMajTicks2( int, double, double, int, double *, double **, int * );
static int FindString( int, const char *[], const char *, const char *, const char *, const char *, int * );
static int Fpoly_ecmp( const void *, const void * );
static int Fpoly_scmp( const void *, const void * );
static int FullForm( const char *, const char *, const char *, const char *, const char *, int * );
static int GCap( AstPlot *, int, int, int * );
static int GVec( AstPlot *, AstMapping *, double *, int, double, AstPointSet **, AstPointSet **, double *, double *, double *, double *, int *, const char *, const char *, int * );
static int GetUseColour( AstPlot *, int, int * );
static int GetUseFont( AstPlot *, int, int * );
static int GetUseStyle( AstPlot *, int, int * );
static int GraphGrid( int, int, double, double, double, double, double **, int * );
static int HasEscapes( const char *, int * );
static int IdFind( int, int, int *, int *, int *, int * );
static int Inside( int, float *, float *, float, float, int * );
static int IsASkyAxis( AstFrame *, int, int * );
static int IsASkyFrame( AstObject *, int * );
static int Labelat( AstPlot *, TickInfo **, AstPlotCurveData **, double *, const char *, const char *, int * );
static int Overlap( AstPlot *, int, int, const char *, float, float, const char *, float, float, float **, const char *, const char *, int * );
static int PopGat( AstPlot *, float *, const char *, const char *, int * );
static int TestUseColour( AstPlot *, int, int * );
static int TestUseFont( AstPlot *, int, int * );
static int TestUseSize( AstPlot *, int, int * );
static int TestUseStyle( AstPlot *, int, int * );
static int TestUseWidth( AstPlot *, int, int * );
static int ToggleLogLin( AstPlot *, int, int, const char *, int * );
static int TraceBorder( AstPlot *, AstMapping *, double, double, double, double, int, double, int[ 4 ], const char *, const char *, int * );
static int Ustrcmp( const char *, const char *, int * );
static int Ustrncmp( const char *, const char *, size_t, int * );
static int swapEdges( AstPlot *, TickInfo **, AstPlotCurveData **, int * );
static void AddCdt( AstPlotCurveData *, AstPlotCurveData *, const char *, const char *, int * );
static void Apoly( AstPlot *, float, float, int * );
static void AxPlot( AstPlot *, int, const double *, double, int, AstPlotCurveData *, const char *, const char *, int * );
static void BBuf( AstPlot *, int * );
static void BoundingBox( AstPlot *, float[2], float[2], int * );
static void Bpoly( AstPlot *, float, float, int * );
static void Clip( AstPlot *, int, const double [], const double [], int * );
static void Copy( const AstObject *, AstObject *, int * );
static void CopyPlotDefaults( AstPlot *, int, AstPlot *, int, int * );
static void Crv( AstPlot *this, double *, double *, double *, int, double *, CrvStatics *, const char *, const char *, int * );
static void CrvLine( AstPlot *this, double, double, double, double, const char *, const char *, int * );
static void Curve( AstPlot *, const double [], const double [], int * );
static void CurvePlot( AstPlot *, const double *, const double *, int , AstPlotCurveData *, const char *, const char *, int * );
static void Delete( AstObject *, int * );
static void DrawAxis( AstPlot *, TickInfo **, double *, double *, const char *, const char *, int * );
static void DrawText( AstPlot *, int, int, const char *, float, float, const char *, float, float, float *, float *, float *, const char *, const char *, int * );
static void DrawTicks( AstPlot *, TickInfo **, int, double *, double *, const char *, const char *, int * );
static void Dump( AstObject *, AstChannel *, int * );
static void EBuf( AstPlot *, int * );
static void Fpoly( AstPlot *, const char *, const char *, int * );
static void GAttr( AstPlot *, int, double, double *, int, const char *, const char *, int * );
static void GBBuf( AstPlot *, const char *, const char *, int * )__attribute__((unused));
static void GEBuf( AstPlot *, const char *, const char *, int * )__attribute__((unused));
static void GFlush( AstPlot *, const char *, const char *, int * )__attribute__((unused));
static void GLine( AstPlot *, int, const float *, const float *, const char *, const char *, int * );
static void GMark( AstPlot *, int, const float *, const float *, int, const char *, const char *, int * );
static void GQch( AstPlot *, float *, float *, const char *, const char *, int * );
static void GScales( AstPlot *, float *, float *, const char *, const char *, int * );
static void GText( AstPlot *, const char *, float, float, const char *, float, float, const char *, const char *, int * );
static void GTxExt( AstPlot *, const char *, float , float, const char *, float, float, float *, float *, const char *, const char *, int * );
static void GenCurve( AstPlot *, AstMapping *, int * );
static void GrfPop( AstPlot *, int * );
static void GrfPush( AstPlot *, int * );
static void GrfSet( AstPlot *, const char *,  AstGrfFun, int * );
static void GrfWrapper( AstPlot *, const char *,  AstGrfWrap, int * );
static void Grid( AstPlot *, int * );
static void GridLine( AstPlot *, int, const double [], double, int * );
static void InterpEscape( AstPlot *, int, double, float *, float *, float, float, float, float, const char *, float *, double, double, double, double, double, const char *, const char *, int * );
static void Labels( AstPlot *, TickInfo **, AstPlotCurveData **, double *, double *, const char *, const char *, int * );
static void LinePlot( AstPlot *, double, double, double, double, int, AstPlotCurveData *, const char *, const char *, int * );
static void Map1( int, double *, double *, double *, const char *, const char *, int * GLOBALS_PROTO );
static void Map2( int, double *, double *, double *, const char *, const char *, int * GLOBALS_PROTO );
static void Map3( int, double *, double *, double *, const char *, const char *, int * GLOBALS_PROTO );
static void Map4( int, double *, double *, double *, const char *, const char *, int * GLOBALS_PROTO );
static void Map5( int, double *, double *, double *, const char *, const char *, int * GLOBALS_PROTO );
static void Mark( AstPlot *, int, int, int, const double *, int, int * );
static void Mirror( AstPlot *, int, int * );
static void Norm1( AstMapping *, int, int, double *, double, double, int * );
static void Opoly( AstPlot *, int * );
static void PlotLabels( AstPlot *, int, AstFrame *, int, LabelList *, char *, int, float **, const char *, const char *, int * );
static void PolyCurve( AstPlot *, int, int, int, const double *, int * );
static void PurgeCdata( AstPlotCurveData *, int * );
static void PushGat( AstPlot *, float, const char *, const char *, int * );
static void RegionOutline( AstPlot *, AstRegion *, int * );
static void RemoveFrame( AstFrameSet *, int, int * );
static void RightVector( AstPlot *, float *, float *, float *, float *, const char *, const char *, int * );
static void SaveTick( AstPlot *, int, double, double, int, int * );
static void SetTickValues( AstPlot *, int, int, double *, int, double *, int * );
static void Text( AstPlot *, const char *, const double [], const float [], const char *, int * );
static void TextLabels( AstPlot *, int, int *, const char *, const char *, int * );
static void Ticker( AstPlot *, int, int, double, double *, double, int, int, EdgeCrossingsStatics **, const char *, const char *, int * );
static void UpdateConcat( float *, float *, float, float, float, float, float *, float *, float, float, float *, float *, float *, float *, int * );

#if defined(THREAD_SAFE)
static int ManageLock( AstObject *, int, int, AstObject **, int * );
#endif

/* Functions which access class attributes. */
/* =======================================  */
/* Implement member functions to access the attributes associated with this
   class using the macros defined for this purpose in the "object.h" file. For
   a description of each attribute, see the class interface (in the associated
   .h file). */

/* Tol. */
/* ---- */
/*
*att++
*  Name:
*     Tol

*  Purpose:
*     Plotting tolerance.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute specifies the plotting tolerance (or resolution)
*     to be used for the graphical output produced by a Plot.  Smaller
*     values will result in smoother and more accurate curves being
*     drawn, but may slow down the plotting process. Conversely,
*     larger values may speed up the plotting process in cases where
*     high resolution is not required.
*
*     The Tol value should be given as a fraction of the minimum
*     dimension of the plotting area, and should lie in the range
c     from 1.0e-7 to 1.0. By default, a value of 0.01 is used.
f     from 1.0E-7 to 1.0. By default, a value of 0.01 is used.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*att--
*/
/* The plotting tolerance. Has a value of -1.0 when not set yielding a
default value of 0.01. Usable values are in the range 1.0E-7 to 1.0. */
astMAKE_CLEAR(Plot,Tol,tol,-1.0)
astMAKE_GET(Plot,Tol,double,0.01,(this->tol == -1.0 ? 0.01 : this->tol))
astMAKE_SET(Plot,Tol,double,tol,astMIN(astMAX(value,1.0E-7),1.0))
astMAKE_TEST(Plot,Tol,( this->tol != -1.0 ))

/* Grid. */
/* ----- */
/*
*att++
*  Name:
*     Grid

*  Purpose:
*     Draw grid lines for a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether grid lines (a grid of curves marking the "major" values
*     on each axis) are drawn across the plotting area.
*
*     If the Grid value of a Plot is non-zero, then grid lines will be
*     drawn. Otherwise, short tick marks on the axes are used to mark
*     the major axis values.  The default behaviour is to use tick
*     marks if the entire plotting area is filled by valid physical
*     coordinates, but to draw grid lines otherwise.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The spacing between major axis values, which determines the
*     spacing of grid lines, may be set using the Gap(axis) attribute.
*att--
*/
/* If non-zero use lines instead of tick marks in a coordinate grid. Has a
value of -1 when not set yielding a default value of 0. */
astMAKE_CLEAR(Plot,Grid,grid,-1)
astMAKE_GET(Plot,Grid,int,0,(this->grid == -1 ? 0 : this->grid))
astMAKE_SET(Plot,Grid,int,grid,( value ? 1 : 0 ))
astMAKE_TEST(Plot,Grid,( this->grid != -1 ))

MAKE_GET2(Plot,Grid,int,0,this->ugrid)
MAKE_SET2(Plot,Grid,int,ugrid,( value ? 1 : 0 ))

/* Invisible. */
/* ---------- */
/*
*att++
*  Name:
*     Invisible

*  Purpose:
*     Draw graphics using invisible ink?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of all graphics produced by
*     Plot methods by determining whether graphics should be visible or
*     invisible.
*
*     If the Invisible value of a Plot is non-zero, then all the Plot
*     methods which normally generate graphical output do not do so (you
*     can think of them drawing with "invisible ink"). Such methods do,
*     however, continue to do all the calculations which would be needed to
*     produce the graphics. In particular, the bounding box enclosing the
*     graphics is still calculated and can be retrieved as normal using
c     astBoundingBox. The default value is zero, resulting in all methods
f     AST_BOUNDINGBOX. The default value is zero, resulting in all methods
*     drawing graphics as normal, using visible ink.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*att--
*/
/* If non-zero use invisible ink. Has a value of -1 when not set yielding
a default value of 0. */
astMAKE_CLEAR(Plot,Invisible,invisible,-1)
astMAKE_GET(Plot,Invisible,int,0,(this->invisible == -1 ? 0 : this->invisible))
astMAKE_SET(Plot,Invisible,int,invisible,( value ? 1 : 0 ))
astMAKE_TEST(Plot,Invisible,( this->invisible != -1 ))

/* TickAll */
/* ------- */
/*
*att++
*  Name:
*     TickAll

*  Purpose:
*     Draw tick marks on all edges of a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether tick marks should be drawn on all edges of a Plot.
*
*     If the TickAll value of a Plot is non-zero (the default), then
*     tick marks will be drawn on all edges of the Plot. Otherwise,
*     they will be drawn only on those edges where the numerical and
*     descriptive axis labels are drawn (see the Edge(axis)
*     attribute).

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - In some circumstances, numerical labels and tick marks are
*     drawn along grid lines inside the plotting area, rather than
*     around its edges (see the Labelling attribute).  In this case,
*     the value of the TickAll attribute is ignored.
*att--
*/
/* If non-zero put tick marks on opposite edges. Has a value of -1 when not
set yielding a default value of 1. */
astMAKE_CLEAR(Plot,TickAll,tickall,-1)
astMAKE_GET(Plot,TickAll,int,1,(this->tickall == -1 ? 1 : this->tickall))
astMAKE_SET(Plot,TickAll,int,tickall,( value ? 1 : 0 ))
astMAKE_TEST(Plot,TickAll,( this->tickall != -1 ))

/* ForceExterior */
/* ------------- */
/*
*att+
*  Name:
*     ForceExterior

*  Purpose:
*     Force the use of exterior labelling?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by forcing
f     coordinate grid (drawn with the AST_GRID routine) by forcing
*     labels and tick marks to be drawn round the edges of the plot
*     (rather than across the middle of the plot), even if there appear
*     to be insufficient edge crossings to justify the use of exterior
*     labelling.
*
*     The default value of zero results in the decision about whether to
*     use interior or exterior labelling being made purely on the basis
*     of the value of the Labelling attribute. If ForceExterior is set to
*     a non-zero value, then the Labelling attribute is ignored and exterior
*     labelling will always be attempted, even if there appear to be
*     insufficient edge labels to justify their use.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The value of this attribute is currently under investigation, and
*     so this attribute prologue is currently marked as protected rather
*     than public (in order to prevent it being included in the public
*     documentation).
*att-
*/
astMAKE_CLEAR(Plot,ForceExterior,forceexterior,-1)
astMAKE_GET(Plot,ForceExterior,int,0,(this->forceexterior == -1 ? 0 : this->forceexterior))
astMAKE_SET(Plot,ForceExterior,int,forceexterior,( value ? 1 : 0 ))
astMAKE_TEST(Plot,ForceExterior,( this->forceexterior != -1 ))

/*
*att++
*  Name:
*     Border

*  Purpose:
*     Draw a border around valid regions of a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether a border is drawn around regions corresponding to the
c     valid physical coordinates of a Plot (c.f. astBorder).
f     valid physical coordinates of a Plot (c.f. AST_BORDER).
*
*     If the Border value of a Plot is non-zero, then this border will
*     be drawn as part of the grid. Otherwise, the border is not drawn
*     (although axis labels and tick marks will still appear, unless
*     other relevant Plot attributes indicate that they should
*     not). The default behaviour is to draw the border if tick marks
*     and numerical labels will be drawn around the edges of the
*     plotting area (see the Labelling attribute), but to omit it
*     otherwise.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*att--
*/
/* If non-zero draw the border. Has a value of -1 when not set, yeilding
   a default of 1. */
astMAKE_CLEAR(Plot,Border,border,-1)
astMAKE_SET(Plot,Border,int,border,( value ? 1 : 0 ))
astMAKE_TEST(Plot,Border,( this->border != -1 ))
astMAKE_GET(Plot,Border,int,1,(this->border == -1 ? 1 : this->border))

MAKE_SET2(Plot,Border,int,uborder,( value ? 1 : 0 ))
MAKE_GET2(Plot,Border,int,1,this->uborder)

/* Clip */
/* ---- */
/*
*att++
*  Name:
*     Clip

*  Purpose:
*     Clip lines and/or markers at the Plot boundary?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer.

*  Description:
*     This attribute controls whether curves and markers are clipped at the
*     boundary of the graphics box specified when the Plot was created. A
*     value of 3 implies both markers and curves are clipped at the Plot
*     boundary. A value of 2 implies markers are clipped, but not curves. A
*     value of 1 implies curves are clipped, but not markers. A value of
*     zero implies neither curves nor markers are clipped. The default
*     value is 1. Note, this attributes controls only the clipping
*     performed internally within AST. The underlying graphics system may
*     also apply clipping. In such cases, removing clipping using this
*     attribute does not guarantee that no clipping will be visible in the
*     final plot.
*
c     The astClip function
f     The AST_CLIP routine
*     can be used to establish generalised clipping within arbitrary
*     regions of the Plot.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*att--
*/
astMAKE_CLEAR(Plot,Clip,clip,-1)
astMAKE_GET(Plot,Clip,int,0,(this->clip == -1 ? 1 : this->clip))
astMAKE_TEST(Plot,Clip,( this->clip != -1 ))
astMAKE_SET(Plot,Clip,int,clip,((value>=0&&value<=3)?value:(astError( AST__ATTIN, "astSetClip(Plot): Invalid value %d supplied for Clip attribute", status, value ), this->clip)))

/* ClipOp */
/* ------ */
/*
*att++
*  Name:
*     ClipOp

*  Purpose:
*     Combine Plot clipping limits using a boolean OR?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls how the clipping limits specified for
c     each axis of a Plot (using the astClip function) are
f     each axis of a Plot (using the AST_CLIP routine) are
*     combined. This, in turn, determines which parts of the graphical
*     output will be visible.
*
*     If the ClipOp attribute of a Plot is zero (the default),
*     graphical output is visible only if it satisfies the clipping
*     limits on all the axes of the clipping Frame (a boolean
*     AND). Otherwise, if ClipOp is non-zero, output is visible if it
*     satisfies the clipping limits on one or more axes (a boolean
*     OR).
*
*     An important use of this attribute is to allow areas of a Plot
*     to be left clear (e.g. as a background for some text). To
*     achieve this, the lower and upper clipping bounds supplied to
c     astClip should be reversed, and the ClipOp attribute of the
f     AST_CLIP should be reversed, and the ClipOp attribute of the
*     Plot should be set to a non-zero value.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*att--
*/
/* If non-zero only 1axis need be within the clipping bounds to avoid a
point being clipped. Otherwise, all axes must be within bounds. */
astMAKE_CLEAR(Plot,ClipOp,clipop,-1)
astMAKE_GET(Plot,ClipOp,int,0,(this->clipop == -1 ? 0 : this->clipop))
astMAKE_SET(Plot,ClipOp,int,clipop,( value ? 1 : 0 ))
astMAKE_TEST(Plot,ClipOp,( this->clipop != -1 ))

/* Grf. */
/* ---- */
/*
*att++
*  Name:
*     Grf

*  Purpose:
c     Use Grf functions registered through astGrfSet?
f     Use Grf routines registered through AST_GRFSET?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
c     This attribute selects the functions which are used to draw graphics by
c     the Plot class. If it is zero, then the functions in the graphics
c     interface selected at link-time are used (see the ast_link script).
c     Otherwise, functions registered using astGrfSet are used. In this
c     case, if a function is needed which has not been registered,
c     then the function in the graphics interface selected at link-time is
c     used.
f     This attribute selects the routines which are used to draw graphics by
f     the Plot class. If it is zero, then the routines in the graphics
f     interface selected at link-time are used (see the ast_link script).
f     Otherwise, routines registered using AST_GRFSET are used. In this
f     case, if a routine is needed which has not been registered,
f     then the routine in the graphics interface selected at link-time is
f     used.

*     The default is to use the graphics interface

*  Applicability:
*     Plot
*        All Plots have this attribute.
*     Plot3D
*        The Plot3D class ignores this attributes, assuming a value of
*        zero.

*  Notes:
*     - The value of this attribute is not saved when the Plot is written
*     out through a Channel to an external data store. On re-loading such
c     a Plot using astRead, the attribute will be cleared, resulting in the
f     a Plot using AST_READ, the attribute will be cleared, resulting in the
*     graphics interface selected at link-time being used.

*att--
*/
/* Use Grf routines registered using astGrfSet? Has a
value of -1 when not set yielding a default of 0. */
astMAKE_CLEAR(Plot,Grf,grf,-1)
astMAKE_GET(Plot,Grf,int,0,(this->grf == -1 ? 0 : this->grf))
astMAKE_SET(Plot,Grf,int,grf,( value ? 1 : 0 ))
astMAKE_TEST(Plot,Grf,( this->grf != -1 ))

/* DrawTitle */
/* --------- */
/*
*att++
*  Name:
*     DrawTitle

*  Purpose:
*     Draw a title for a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether a title is drawn.
*
*     If the DrawTitle value of a Plot is non-zero (the default), then
*     the title will be drawn, otherwise it will be omitted.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*     Plot3D
*        The Plot3D class ignores this attributes, assuming a value of
*        zero.

*  Notes:
*     - The text used for the title is obtained from the Plot's Title
*     attribute.
*     - The vertical placement of the title can be controlled using
*     the TitleGap attribute.
*att--
*/
/* If non-zero add a title to the grid. Has a value of -1 when not
set yielding a default value of 1. */
astMAKE_CLEAR(Plot,DrawTitle,drawtitle,-1)
astMAKE_GET(Plot,DrawTitle,int,1,(this->drawtitle == -1 ? 1 : this->drawtitle))
astMAKE_SET(Plot,DrawTitle,int,drawtitle,( value ? 1 : 0 ))
astMAKE_TEST(Plot,DrawTitle,( this->drawtitle != -1 ))

/* LabelUp. */
/* -------  */
/*
*att++
*  Name:
*     LabelUp(axis)

*  Purpose:
*     Draw numerical Plot labels upright?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether the numerical labels for each axis of a Plot should be
*     drawn upright or not. It takes a separate value for each
*     physical axis of a Plot so that, for instance, the setting
*     "LabelUp(2)=1" specifies that numerical labels for the second
*     axis should be drawn upright.
*
*     If the LabelUp value of a Plot axis is non-zero, it causes
*     numerical labels for that axis to be plotted upright (i.e. as
*     normal, horizontal text), otherwise labels are drawn parallel to
*     the axis to which they apply.
*
*     The default is to produce upright labels if the labels are placed
*     around the edge of the plot, and to produce labels that follow the
*     axes if the labels are placed within the interior of the plot (see
*     attribute Labelling).

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - In some circumstances, numerical labels and tick marks are
*     drawn around the edges of the plotting area (see the Labelling
*     attribute).  In this case, the value of the LabelUp attribute is
*     ignored.
*     - If no axis is specified, (e.g. "LabelUp" instead of
*     "LabelUp(2)"), then a "set" or "clear" operation will affect the
*     attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the LabelUp(1) value.
*att--
*/
/* Are numerical labels to be displayed on each axis? Has a value of -1 when
not set yielding a value of 0 (no) for both axes. */
MAKE_CLEAR(LabelUp,labelup,-1,0)
MAKE_GET(LabelUp,int,0,( this->labelup[axis] == -1 ? 0 : this->labelup[axis] ),0)
MAKE_TEST(LabelUp,( this->labelup[axis] != -1 ),0)
MAKE_SET(LabelUp,int,labelup,( value ? 1 : 0 ),0)

/* DrawAxes */
/* -------- */
/*
*att++
*  Name:
*     DrawAxes(axis)

*  Purpose:
*     Draw axes for a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether curves representing coordinate axes should be drawn.
*     It takes a separate value for each physical axis of a
*     Plot so that, for instance, the setting "DrawAxes(2)=0"
*     specifies that no axis should be drawn for the second axis.
*
*     If drawn, these axis lines will pass through any tick marks
*     associated with numerical labels drawn to mark values on the
*     axes. The location of these tick marks and labels (and hence the
*     axis lines) is determined by the Plot's LabelAt(axis) attribute.
*
*     If the DrawAxes value of a Plot is non-zero (the default), then
*     axis lines will be drawn, otherwise they will be omitted.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - Axis lines are drawn independently of any coordinate grid
*     lines (see the Grid attribute) so grid lines may be used to
*     substitute for axis lines if required.
*     - In some circumstances, numerical labels and tick marks are
*     drawn around the edges of the plotting area (see the Labelling
*     attribute).  In this case, the value of the DrawAxes attribute
*     is ignored.
*     - If no axis is specified, (e.g. "DrawAxes" instead of
*     "DrawAxes(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the DrawAxes(1) value.
*att--
*/
/* If non-zero draw a curve through the tick marks. Has a value of -1
   when not set yielding a default value of 1. */
MAKE_CLEAR(DrawAxes,drawaxes,-1,0)
MAKE_GET(DrawAxes,int,1,( this->drawaxes[axis] == -1 ? 1 : this->drawaxes[axis] ),0)
MAKE_TEST(DrawAxes,( this->drawaxes[axis] != -1 ),0)
MAKE_SET(DrawAxes,int,drawaxes,( value ? 1 : 0 ),0)

/* Abbrev */
/* -------- */
/*
*att++
*  Name:
*     Abbrev(axis)

*  Purpose:
*     Abbreviate leading fields within numerical axis labels?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether matching leading fields should be removed from adjacent
*     numerical axis labels. It takes a separate value for each physical
*     axis of a Plot so that, for instance, the setting "Abbrev(2)=0"
*     specifies that matching leading fields should not be removed on
*     the second axis.
*
*     If the Abbrev value of a Plot is non-zero (the default), then
*     leading fields will be removed from adjacent axis labels if they
*     are equal.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - If no axis is specified, (e.g. "Abbrev" instead of
*     "Abbrev(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the Abbrev(1) value.
*att--
*/
MAKE_CLEAR(Abbrev,abbrev,-1,0)
MAKE_GET(Abbrev,int,1,( this->abbrev[axis] == -1 ? 1 : this->abbrev[axis] ),0)
MAKE_TEST(Abbrev,( this->abbrev[axis] != -1 ),0)
MAKE_SET(Abbrev,int,abbrev,( value ? 1 : 0 ),0)

/* Escape. */
/* ------- */
/*
*att++
*  Name:
*     Escape

*  Purpose:
*     Allow changes of character attributes within strings?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of text strings and numerical
c     labels drawn by the astGrid and (for the Plot class) astText functions,
f     labels drawn by the AST_GRID and (for the Plot class) AST_TEXT routines,
*     by determining if any escape sequences contained within the strings
*     should be used to control the appearance of the text, or should
*     be printed literally. Note, the Plot3D class only interprets escape
*     sequences within the
c     astGrid function.
f     AST_GRID routine.
*
*     If the Escape value of a Plot is one (the default), then any
*     escape sequences in text strings produce the effects described
*     below when printed. Otherwise, they are printed literally.
*
c     See also the astEscapes function.
f     See also the AST_ESCAPES function.

*  Escape Sequences:
*     Escape sequences are introduced into the text string by a percent
*     "%" character. Any unrecognised, illegal or incomplete escape sequences
*     are printed literally. The following escape sequences are
*     currently recognised ("..." represents a string of one or more
*     decimal digits):
*
*       %%      - Print a literal "%" character.
*
*       %^...+  - Draw subsequent characters as super-scripts. The digits
*                 "..." give the distance from the base-line of "normal"
*                 text to the base-line of the super-script text, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*       %^+     - Draw subsequent characters with the normal base-line.
*
*       %v...+  - Draw subsequent characters as sub-scripts. The digits
*                 "..." give the distance from the base-line of "normal"
*                 text to the base-line of the sub-script text, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*
*       %v+     - Draw subsequent characters with the normal base-line
*                 (equivalent to %^+).
*
*       %>...+  - Leave a gap before drawing subsequent characters.
*                 The digits "..." give the size of the gap, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*
*       %<...+  - Move backwards before drawing subsequent characters.
*                 The digits "..." give the size of the movement, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*
*       %s...+  - Change the Size attribute for subsequent characters. The
*                 digits "..." give the new Size as a fraction of the
*                 "normal" Size, scaled so that a value of "100" corresponds
*                 to 1.0;
*
*       %s+     - Reset the Size attribute to its "normal" value.
*
*       %w...+  - Change the Width attribute for subsequent characters. The
*                 digits "..." give the new width as a fraction of the
*                 "normal" Width, scaled so that a value of "100" corresponds
*                 to 1.0;
*
*       %w+     - Reset the Size attribute to its "normal" value.
*
*       %f...+  - Change the Font attribute for subsequent characters. The
*                 digits "..." give the new Font value.
*
*       %f+     - Reset the Font attribute to its "normal" value.
*
*       %c...+  - Change the Colour attribute for subsequent characters. The
*                 digits "..." give the new Colour value.
*
*       %c+     - Reset the Colour attribute to its "normal" value.
*
*       %t...+  - Change the Style attribute for subsequent characters. The
*                 digits "..." give the new Style value.
*
*       %t+     - Reset the Style attribute to its "normal" value.
*
*       %h+     - Remember the current horizontal position (see "%g+")
*
*       %g+     - Go to the horizontal position of the previous "%h+" (if any).
*
*       %-      - Push the current graphics attribute values onto the top of
*                 the stack (see "%+").
*
*       %+      - Pop attributes values of the top the stack (see "%-"). If
*                 the stack is empty, "normal" attribute values are restored.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*att--
*/

/* Has a value of -1 when not set yeilding a default of 1. */
astMAKE_GET(Plot,Escape,int,1,(this->escape == -1 ? 1 : this->escape))
astMAKE_CLEAR(Plot,Escape,escape,-1)
astMAKE_SET(Plot,Escape,int,escape,( value ? 1 : 0 ))
astMAKE_TEST(Plot,Escape,( this->escape != -1 ))

/* LabelAt(axis). */
/* -------------- */
/*
*att++
*  Name:
*     LabelAt(axis)

*  Purpose:
*     Where to place numerical labels for a Plot

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     where numerical axis labels and associated tick marks are
*     placed.  It takes a separate value for each physical axis of a
*     Plot so that, for instance, the setting "LabelAt(2)=10.0"
*     specifies where the numerical labels and tick marks for the
*     second axis should be drawn.
*
*     For each axis, the LabelAt value gives the value on the other
*     axis at which numerical labels and tick marks should be placed
c     (remember that Plots suitable for use with astGrid may only
f     (remember that Plots suitable for use with AST_GRID may only
*     have two axes).  For example, in a celestial (RA,Dec) coordinate
*     system, LabelAt(1) gives a Dec value which defines a line (of
*     constant Dec) along which the numerical RA labels and their
*     associated tick marks will be drawn. Similarly, LabelAt(2) gives
*     the RA value at which the Dec labels and ticks will be drawn.
*
*     The default bahaviour is for the Plot to generate its own
*     position for numerical labels and tick marks.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The LabelAt value should use the same units as are used
*     internally for storing coordinate values on the appropriate
*     axis. For example, with a celestial coordinate system, the
*     LabelAt value should be in radians, not hours or degrees.
*     - Normally, the LabelAt value also determines where the lines
*     representing coordinate axes will be drawn, so that the tick
*     marks will lie on these lines (but also see the DrawAxes
*     attribute).
*     - In some circumstances, numerical labels and tick marks are
*     drawn around the edges of the plotting area (see the Labelling
*     attribute).  In this case, the value of the LabelAt attribute is
*     ignored.
*att--
*/
/* The constant value on the other axis at which to place labels for
   each axis. */
MAKE_CLEAR(LabelAt,labelat,AST__BAD,0)
MAKE_GET(LabelAt,double,AST__BAD,this->labelat[axis],0)
MAKE_SET(LabelAt,double,labelat,value,0)
MAKE_TEST(LabelAt,( this->labelat[axis] != AST__BAD ),0)

MAKE_GET3(LabelAt,double,AST__BAD,this->ulblat[axis],0)
MAKE_SET3(LabelAt,double,ulblat,value,0)

/* Centre(axis). */
/* ------------ */
/* A value at which to place a tick mark. Other ticks marks are spaced at
regular distances from this one. AST__BAD is stored if no value is supplied,
resulting in Plot choosing its own value. */
MAKE_CLEAR(Centre,centre,AST__BAD,0)
MAKE_GET(Centre,double,AST__BAD,this->centre[axis],0)
MAKE_SET(Centre,double,centre,value,0)
MAKE_TEST(Centre,( this->centre[axis] != AST__BAD ),0)

MAKE_GET3(Centre,double,AST__BAD,this->ucentre[axis],0)
MAKE_SET3(Centre,double,ucentre,value,0)

/* Ink */
/* --- */
/* A protected attribute indicating if astGrid should draw using visible
ink. The unset value is -1, yeilding a default value of 1. */
astMAKE_CLEAR(Plot,Ink,ink,-1)
astMAKE_GET(Plot,Ink,int,1,(this->ink == -1 ? 1 : this->ink))
astMAKE_SET(Plot,Ink,int,ink,( value ? 1 : 0 ))
astMAKE_TEST(Plot,Ink,( this->ink != -1 ))

/* Gap(axis). */
/* ---------- */
/*
*att++
*  Name:
*     Gap(axis)

*  Purpose:
*     Interval between linearly spaced major axis values of a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     the linear interval between the "major" axis values of a Plot, at
*     which (for example) major tick marks are drawn. It takes a separate
*     value for each physical axis of the Plot so that, for instance,
*     the setting "Gap(2)=3.0" specifies the difference between adjacent major
*     values along the second axis. The Gap attribute is only used when
*     the LogTicks attribute indicates that the spacing between major axis
*     values is to be linear. If major axis values are logarithmically spaced
*     then the gap is specified using attribute LogGap.
*
*     The Gap value supplied will usually be rounded to the nearest
*     "nice" value, suitable (e.g.) for generating axis labels, before
*     use. To avoid this "nicing" you should set an explicit format
*     for the axis using the Format(axis) or Digits/Digits(axis)
*     attribute. The default behaviour is for the Plot to generate its
*     own Gap value when required, based on the range of axis values
*     to be represented.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The Gap value should use the same units as are used internally
*     for storing coordinate values on the corresponding axis. For
*     example, with a celestial coordinate system, the Gap value
*     should be in radians, not hours or degrees.
*     - If no axis is specified, (e.g. "Gap" instead of "Gap(2)"),
*     then a "set" or "clear" operation will affect the attribute
*     value of all the Plot axes, while a "get" or "test" operation
*     will use just the Gap(1) value.
*att--
*/
/* The gap between tick marks on each axis. AST__BAD is stored if no
value has been supplied, resulting in default values being found. */
MAKE_CLEAR(Gap,gap,AST__BAD,0)
MAKE_SET(Gap,double,gap,value,0)
MAKE_TEST(Gap,( this->gap[axis] != AST__BAD ),0)
MAKE_GET(Gap,double,AST__BAD,this->gap[axis],0)

MAKE_SET3(Gap,double,ugap,value,0)
MAKE_GET3(Gap,double,AST__BAD,this->ugap[axis],0)

/* LogGap(axis). */
/* ---------- */
/*
*att++
*  Name:
*     LogGap(axis)

*  Purpose:
*     Interval between major axis values of a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     the logarithmic interval between the "major" axis values of a Plot, at
*     which (for example) major tick marks are drawn. It takes a separate
*     value for each physical axis of the Plot so that, for instance,
*     the setting "LogGap(2)=100.0" specifies the ratio between adjacent major
*     values along the second axis. The LogGap attribute is only used when
*     the LogTicks attribute indicates that the spacing between major axis
*     values is to be logarithmic. If major axis values are linearly spaced
*     then the gap is specified using attribute Gap.
*
*     The LogGap value supplied will be rounded to the nearest power of 10.
*     The reciprocal of the supplied value may be used if this is necessary
*     to produce usable major axis values. If a zero or negative value is
*     supplied, an error will be reported when the grid is drawn. The default
*     behaviour is for the Plot to generate its own LogGap value when
*     required, based on the range of axis values to be represented.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The LogGap value is a ratio between axis values and is therefore
*     dimensionless.
*     - If no axis is specified, (e.g. "LogGap" instead of "LogGap(2)"),
*     then a "set" or "clear" operation will affect the attribute
*     value of all the Plot axes, while a "get" or "test" operation
*     will use just the LogGap(1) value.
*att--
*/
/* The logarithmic gap between tick marks on each axis. AST__BAD is stored if
   no value has been supplied, resulting in default values being found. */
MAKE_CLEAR(LogGap,loggap,AST__BAD,0)
MAKE_SET(LogGap,double,loggap,value,0)
MAKE_TEST(LogGap,( this->loggap[axis] != AST__BAD ),0)
MAKE_GET(LogGap,double,AST__BAD,this->loggap[axis],0)

MAKE_SET3(LogGap,double,uloggap,value,0)
MAKE_GET3(LogGap,double,AST__BAD,this->uloggap[axis],0)

/* LogPlot. */
/* -------  */
/*
*att++
*  Name:
*     LogPlot(axis)

*  Purpose:
*     Map the plot logarithmically onto the screen?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of all graphics produced by
*     the Plot, by determining whether the axes of the plotting surface
*     are mapped logarithmically or linearly onto the base Frame of the
*     FrameSet supplied when the Plot was constructed. It takes a separate
*     value for each axis of the graphics coordinate system (i.e. the
*     base Frame in the Plot) so that, for instance, the setting
*     "LogPlot(2)=1" specifies that the second axis of the graphics
*     coordinate system (usually the vertical axis) should be mapped
*     logarithmically onto the second axis of the base Frame of the
*     FrameSet supplied when the Plot was constructed.
*
*     If the LogPlot value of a Plot axis is non-zero, it causes that
*     axis to be mapped logarithmically, otherwise (the default) the axis
*     is mapped linearly.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The setting of the LogPlot attribute provides the default value
*     for the related LogTicks attribute. By selecting suitable values for
*     LogPlot and LogTicks, it is possible to have tick marks which are evenly
*     spaced in value but which are mapped logarithmically onto the screen
*     (and vice-versa).
*     - An axis may only be mapped logarithmically if the visible part of
*     the axis does not include the value zero. The visible part of the
*     axis is that part which is mapped onto the plotting area, and is
*     measured within the base Frame of the FrameSet which was supplied when
*     the Plot was constructed. Any attempt to set LogPlot to a non-zero value
*     will be ignored (without error) if the visible part of the axis
*     includes the value zero
*     - If no axis is specified, (e.g. "LogPlot" instead of
*     "LogPlot(2)"), then a "set" or "clear" operation will affect the
*     attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the LogPlot(1) value.
*att--
*/
/* Are plot axes to be mapped logarithmically? Has a value of -1 when
not set yielding a value of 0 (no) for both axes. */
MAKE_GET(LogPlot,int,0,( this->logplot[axis] == -1 ? 0 : this->logplot[axis] ),0)
MAKE_TEST(LogPlot,( this->logplot[axis] != -1 ),0)

/* LogTicks. */
/* -------  */
/*
*att++
*  Name:
*     LogTicks(axis)

*  Purpose:
*     Space the major tick marks logarithmically?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether the major tick marks should be spaced logarithmically or
*     linearly in axis value. It takes a separate value for each physical
*     axis of the Plot so that, for instance, the setting "LogTicks(2)=1"
*     specifies that the major tick marks on the second axis should be
*     spaced logarithmically.
*
*     If the LogTicks value for a physical axis is non-zero, the major
*     tick marks on that axis will be spaced logarithmically (that is,
*     there will be a constant ratio between the axis values at adjacent
*     major tick marks). An error will be reported if the dynamic range of
*     the axis (the ratio of the largest to smallest displayed axis value)
*     is less than 10.0. If the LogTicks value is zero, the major tick marks
*     will be evenly spaced (that is, there will be a constant difference
*     between the axis values at adjacent major tick marks). The default is
*     to produce logarithmically spaced tick marks if the corresponding
*     LogPlot attribute is non-zero and the ratio of maximum axis value
*     to minimum axis value is 100 or more. If either of these conditions
*     is not met, the default is to produce linearly spaced tick marks.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The setting of the LogTicks attribute does not affect the mapping
*     of the plot onto the screen, which is controlled by attribute LogPlot.
*     By selecting suitable values for LogPlot and LogTicks, it is possible to
*     have tick marks which are evenly spaced in value but which are mapped
*     logarithmically onto the screen (and vica-versa).
*     - An error will be reported when drawing an annotated axis grid if
*     the visible part of the physical axis includes the value zero.
*     - If no axis is specified, (e.g. "LogTicks" instead of
*     "LogTicks(2)"), then a "set" or "clear" operation will affect the
*     attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the LogTicks(1) value.
*att--
*/
/* Are ticksto be spaced logarithmically? Has a value of -1 when
   not set, yeielding a default value equal to the corresponding
   LogPlot value. */
MAKE_CLEAR(LogTicks,logticks,-1,0)
MAKE_GET(LogTicks,int,0,( this->logticks[axis] == -1 ? astGetLogPlot(this,axis) : this->logticks[axis] ),0)
MAKE_TEST(LogTicks,( this->logticks[axis] != -1 ),0)
MAKE_SET(LogTicks,int,logticks,( value ? 1 : 0 ),0)

MAKE_SET3(LogTicks,int,ulgtk,value,0)
MAKE_GET3(LogTicks,int,0,this->ulgtk[axis],0)

/* LogLabel. */
/* --------  */
/*
*att++
*  Name:
*     LogLabel(axis)

*  Purpose:
*     Use exponential format for numerical axis labels?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether the numerical axis labels should be in normal decimal form
*     or should be represented as 10 raised to the appropriate power.
*     That is, an axis value of 1000.0 will be drawn as "1000.0" if
*     LogLabel is zero, but as "10^3" if LogLabel is non-zero. If
*     graphical escape sequences are supported (see attribute Escape),
*     the power in such exponential labels will be drawn as a small
*     superscript instead of using a "^" character to represent
*     exponentiation.
*
*     The default is to produce exponential labels if the major tick
*     marks are logarithmically spaced (see the LogTicks attribute).

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - If no axis is specified, (e.g. "LogLabel" instead of
*     "LogLabel(2)"), then a "set" or "clear" operation will affect the
*     attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the LogLabel(1) value.
*att--
*/
/* Are labels to be drawn as 10**x? Has a value of -1 when not set, yeielding
   a default value equal to the corresponding LogTicks value. */
MAKE_CLEAR(LogLabel,loglabel,-1,0)
MAKE_GET(LogLabel,int,0,( this->loglabel[axis] == -1 ? astGetLogTicks(this,axis) : this->loglabel[axis] ),0)
MAKE_TEST(LogLabel,( this->loglabel[axis] != -1 ),0)
MAKE_SET(LogLabel,int,loglabel,( value ? 1 : 0 ),0)

MAKE_SET3(LogLabel,int,ulglb,value,0)
MAKE_GET3(LogLabel,int,0,this->ulglb[axis],0)

/* MajTickLen. */
/* ----------- */
/*
*att++
*  Name:
*     MajTickLen(axis)

*  Purpose:
*     Length of major tick marks for a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     the length of the major tick marks drawn on the axes of a Plot.
*     It takes a separate value for each physical axis of the Plot so
*     that, for instance, the setting "MajTickLen(2)=0" specifies the
*     length of the major tick marks drawn on the second axis.
*
*     The MajTickLen value should be given as a fraction of the
*     minimum dimension of the plotting area. Negative values cause
*     major tick marks to be placed on the outside of the
*     corresponding grid line or axis (but subject to any clipping
*     imposed by the underlying graphics system), while positive
*     values cause them to be placed on the inside.
*
*     The default behaviour depends on whether a coordinate grid is
*     drawn inside the plotting area (see the Grid attribute). If so,
*     the default MajTickLen value is zero (so that major ticks are
*     not drawn), otherwise the default is +0.015.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - If no axis is specified, (e.g. "MajTickLen" instead of
*     "MajTickLen(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the MajTickLen(1) value.

*att--
*/
/* Fractional length of major tick marks. Has a value of AST__BAD when not
set yielding a default value of 0.015. */
MAKE_CLEAR(MajTickLen,majticklen,AST__BAD,0)
MAKE_SET(MajTickLen,double,majticklen,value,0)
MAKE_TEST(MajTickLen,( this->majticklen[axis] != AST__BAD ),0)
MAKE_GET(MajTickLen,double,0.0,( this->majticklen[axis] == AST__BAD ? 0.015 : this->majticklen[axis]),0)

MAKE_SET3(MajTickLen,double,umjtkln,value,0)
MAKE_GET3(MajTickLen,double,0.0,this->umjtkln[axis],0)

/* TitleGap. */
/* --------- */
/*
*att++
*  Name:
*     TitleGap

*  Purpose:
*     Vertical spacing for a Plot title.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     where the title of a Plot is drawn.
*
*     Its value gives the spacing between the bottom edge of the title
*     and a reference point specified by the TextGapType attribute (by
*     default, the top edge of a box enclosing all other parts of the
*     annotated grid). Positive values cause the title to be drawn
*     outside the box, while negative values cause it to be drawn inside.
*
*     The TitleGap value should be given as a fraction of the minimum
*     dimension of the plotting area, the default value being +0.05.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*     Plot3D
*        The Plot3D class ignores this attributes since it does not draw
*        a Title.

*  Notes:
*     - The text used for the title is obtained from the Plot's Title
*     attribute.
*att--
*/
/* Fractional gap between titile and top edge. Has a value of AST__BAD when
not set yielding a default value of 0.05. */
astMAKE_CLEAR(Plot,TitleGap,titlegap,AST__BAD)
astMAKE_GET(Plot,TitleGap,double,0.0,( this->titlegap == AST__BAD ? 0.05 : this->titlegap))
astMAKE_SET(Plot,TitleGap,double,titlegap,value)
astMAKE_TEST(Plot,TitleGap,( this->titlegap != AST__BAD ))

/* MinTickLen. */
/* ----------- */
/*
*att++
*  Name:
*     MinTickLen(axis)

*  Purpose:
*     Length of minor tick marks for a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     the length of the minor tick marks drawn on the axes of a Plot.
*     It takes a separate value for each physical axis of the Plot so
*     that, for instance, the setting "MinTickLen(2)=0" specifies the
*     length of the minor tick marks drawn on the second axis.
*
*     The MinTickLen value should be given as a fraction of the
*     minimum dimension of the plotting area. Negative values cause
*     minor tick marks to be placed on the outside of the
*     corresponding grid line or axis (but subject to any clipping
*     imposed by the underlying graphics system), while positive
*     values cause them to be placed on the inside.
*
*     The default value is +0.007.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The number of minor tick marks drawn is determined by the
*     Plot's MinTick(axis) attribute.
*     - If no axis is specified, (e.g. "MinTickLen" instead of
*     "MinTickLen(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the MinTickLen(1) value.

*att--
*/
/* Fractional length of minor tick marks. Has a value of AST__BAD when not
set yielding a default value of 0.007. */
MAKE_CLEAR(MinTickLen,minticklen,AST__BAD,0)
MAKE_SET(MinTickLen,double,minticklen,value,0)
MAKE_TEST(MinTickLen,( this->minticklen[axis] != AST__BAD ),0)
MAKE_GET(MinTickLen,double,0.0,( this->minticklen[axis] == AST__BAD ? 0.007 : this->minticklen[axis]),0)



/* TextGapType. */
/* ------------ */
/*
*att++
*  Name:
*     TextGapType

*  Purpose:
*     Controls the interpretation of attributes TextLabGap and TitleGap

*  Type:
*     Public attribute.

*  Synopsis:
*     String.

*  Description:
*     This attribute controls how the values supplied for attributes
*     TextLabGap and TitleGap are used. If the TextGapType value is
*     "box" (the default), then the gaps are measured from the nearest
*     edge of the bounding box enclosing all other parts of the annotated
*     grid (excluding other descriptive labels). If the TextGapType value
*     is "plot", then the gaps are measured from the nearest edge of the
*     plotting area.
*
*     Note, this attribute only affects the position from which the gaps
*     are measured - the size of the gap should always be given as a
*     fraction of the minimum dimension of the plotting area.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*att--
*/
astMAKE_CLEAR(Plot,TextGapType,textgaptype,-9999)
astMAKE_SET(Plot,TextGapType,int,textgaptype,(value?1:0))
astMAKE_TEST(Plot,TextGapType,( this->textgaptype != -9999 ))
astMAKE_GET(Plot,TextGapType,int,0,(this->textgaptype == -9999 ? 0 : this->textgaptype))



/* Labelling. */
/* ---------- */
/*
*att++
*  Name:
*     Labelling

*  Purpose:
*     Label and tick placement option for a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     String.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     the strategy for placing numerical labels and tick marks for a Plot.
*
*     If the Labelling value of a Plot is "exterior" (the default), then
*     numerical labels and their associated tick marks are placed
*     around the edges of the plotting area, if possible. If this is
*     not possible, or if the Labelling value is "interior", then they
*     are placed along grid lines inside the plotting area.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The LabelAt(axis) attribute may be used to determine the exact
*     placement of labels and tick marks that are drawn inside the
*     plotting area.
*att--
*/
astMAKE_CLEAR(Plot,Labelling,labelling,-9999)
astMAKE_SET(Plot,Labelling,int,labelling,(value?1:0))
astMAKE_TEST(Plot,Labelling,( this->labelling != -9999 ))
astMAKE_GET(Plot,Labelling,int,0,(this->labelling == -9999 ? 0 : this->labelling))

MAKE_SET2(Plot,Labelling,int,ulbling,(value?1:0))
MAKE_GET2(Plot,Labelling,int,0,this->ulbling)

/* Edge. */
/* ----- */
/*
*att++
*  Name:
*     Edge(axis)

*  Purpose:
*     Which edges to label in a Plot

*  Type:
*     Public attribute.

*  Synopsis:
*     String.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     which edges of a Plot are used for displaying numerical and
*     descriptive axis labels. It takes a separate value for each
*     physical axis of the Plot so that, for instance, the setting
*     "Edge(2)=left" specifies which edge to use to display labels for
*     the second axis.
*
*     The values "left", "top", "right" and "bottom" (or any
*     abbreviation) can be supplied for this attribute. The default is
*     usually "bottom" for the first axis and "left" for the second
*     axis. However, if exterior labelling was requested (see the
*     Labelling attribute) but cannot be produced using these default
*     Edge values, then the default values will be swapped if this
*     enables exterior labelling to be produced.

*  Applicability:
*     Plot
*        All Plots have this attribute.
*     Plot3D
*        The Plot3D class ignores this attributes. Instead it uses its
*        own RootCorner attribute to determine which edges of the 3D plot
*        to label.

*  Notes:
*     - In some circumstances, numerical labels will be drawn along
*     internal grid lines instead of at the edges of the plotting area
*     (see the Labelling attribute). In this case, the Edge attribute
*     only affects the placement of the descriptive labels (these are
*     drawn at the edges of the plotting area, rather than along the
*     axis lines).
*att--
*/
/* The edges of the plotting area on which to place numerical labels
   for axes 0 and 1. Has a value of -1 when not set yielding a value
   of 3 (the bottom edge) for axis 0 and 0 (the left-hand edge) for
   axis 1. */
MAKE_CLEAR(Edge,edge,-1,0)
MAKE_GET(Edge,int,0,( this->edge[axis] == -1 ? (axis?LEFT:BOTTOM) : this->edge[axis] ),0)
MAKE_SET(Edge,int,edge,(abs( value % 4 )),0)
MAKE_TEST(Edge,( this->edge[axis] != -1 ),0)

MAKE_GET3(Edge,int,0,this->uedge[axis],0)
MAKE_SET3(Edge,int,uedge,(abs( value % 4 )),0)

/* NumLab. */
/* -------- */
/*
*att++
*  Name:
*     NumLab(axis)

*  Purpose:
*     Draw numerical axis labels for a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether labels should be drawn to represent the numerical values
*     along each axis of a Plot. It takes a separate value for each
*     physical axis of a Plot so that, for instance, the setting
*     "NumLab(2)=1" specifies that numerical labels should be drawn
*     for the second axis.
*
*     If the NumLab value of a Plot axis is non-zero (the default),
*     then numerical labels will be drawn for that axis, otherwise
*     they will be omitted.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The drawing of associated descriptive axis labels for a Plot
*     (describing the quantity being plotted along each axis) is
*     controlled by the TextLab(axis) attribute.
*     - If no axis is specified, (e.g. "NumLab" instead of
*     "NumLab(2)"), then a "set" or "clear" operation will affect the
*     attribute value of all the Plot axes, while a "get" or "test"
*     operation will use just the NumLab(1) value.
*att--
*/
/* Are numerical labels to be displayed on each axis? Has a value of
   -1 when not set yielding a value of 1 (yes) for both axes. */
MAKE_CLEAR(NumLab,numlab,-1,0)
MAKE_GET(NumLab,int,1,( this->numlab[axis] == -1 ? 1 : this->numlab[axis] ),0)
MAKE_TEST(NumLab,( this->numlab[axis] != -1 ),0)
MAKE_SET(NumLab,int,numlab,( value ? 1 : 0 ),0)

/* NumLabGap. */
/* --------- */
/*
*att++
*  Name:
*     NumLabGap(axis)

*  Purpose:
*     Spacing of numerical labels for a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     where numerical axis labels are placed relative to the axes they
*     describe.  It takes a separate value for each physical axis of a
*     Plot so that, for instance, the setting "NumLabGap(2)=-0.01"
*     specifies where the numerical label for the second axis should
*     be drawn.
*
*     For each axis, the NumLabGap value gives the spacing between the
*     axis line (or edge of the plotting area, if appropriate) and the
*     nearest edge of the corresponding numerical axis
*     labels. Positive values cause the descriptive label to be placed
*     on the opposite side of the line to the default tick marks,
*     while negative values cause it to be placed on the same side.
*
*     The NumLabGap value should be given as a fraction of the minimum
*     dimension of the plotting area, the default value being +0.01.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - If no axis is specified, (e.g. "NumLabGap" instead of
*     "NumLabGap(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the NumLabGap(1) value.
*att--
*/
/* Fractional spacing between numeric labels and axes. Has a value of AST__BAD
when not set yielding a default value of 0.01. */
MAKE_CLEAR(NumLabGap,numlabgap,AST__BAD,0)
MAKE_GET(NumLabGap,double,0.0,( this->numlabgap[ axis ] == AST__BAD ? 0.01 : this->numlabgap[axis]),0)
MAKE_SET(NumLabGap,double,numlabgap,value,0)
MAKE_TEST(NumLabGap,( this->numlabgap[axis] != AST__BAD ),0)

/* MinTick. */
/* -------- */
/*
*att++
*  Name:
*     MinTick(axis)

*  Purpose:
*     Density of minor tick marks for a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     the density of minor tick marks which appear between the major
*     axis values of a Plot. It takes a separate value for each
*     physical axis of a Plot so that, for instance, the setting
*     "MinTick(2)=2" specifies the density of minor tick marks along
*     the second axis.
*
*     The value supplied should be the number of minor divisions
*     required between each pair of major axis values, this being one
*     more than the number of minor tick marks to be drawn.  By
*     default, a value is chosen that depends on the gap between major
*     axis values and the nature of the axis.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - If no axis is specified, (e.g. "MinTick" instead of
*     "MinTick(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the MinTick(1) value.
*att--
*/
/* How many divisions are there between major tick marks? Has a value
of -1 when not set yielding a value of 1 for both axes. */
MAKE_CLEAR(MinTick,mintick,-1,0)
MAKE_GET(MinTick,int,1,( this->mintick[axis] == -1 ? 1 : this->mintick[axis] ),0)
MAKE_TEST(MinTick,( this->mintick[axis] != -1 ),0)
MAKE_SET(MinTick,int,mintick,( (value < 1)? 1 : value ),0)

MAKE_GET3(MinTick,int,1,this->umintk[axis],0)
MAKE_SET3(MinTick,int,umintk,( (value < 1)? 1 : value ),0)

/* TextLab. */
/* --------- */
/*
*att++
*  Name:
*     TextLab(axis)

*  Purpose:
*     Draw descriptive axis labels for a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether textual labels should be drawn to describe the quantity
*     being represented on each axis of a Plot. It takes a separate
*     value for each physical axis of a Plot so that, for instance,
*     the setting "TextLab(2)=1" specifies that descriptive labels
*     should be drawn for the second axis.
*
*     If the TextLab value of a Plot axis is non-zero, then
*     descriptive labels will be drawn for that axis, otherwise they
*     will be omitted. The default behaviour is to draw descriptive
*     labels if tick marks and numerical labels are being drawn around
*     the edges of the plotting area (see the Labelling attribute),
*     but to omit them otherwise.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The text used for the descriptive labels is derived from the
*     Plot's Label(axis) attribute, together with its Unit(axis)
*     attribute if appropriate (see the LabelUnits(axis) attribute).
*     - The drawing of numerical axis labels for a Plot (which
*     indicate values on the axis) is controlled by the NumLab(axis)
*     attribute.
*     - If no axis is specified, (e.g. "TextLab" instead of
*     "TextLab(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the TextLab(1) value.
*att--
*/
/* Are textual labels to be displayed on each axis? Has a value of -1
   when not set yielding a value of 1 (yes) for both axes. */
MAKE_CLEAR(TextLab,textlab,-1,0)
MAKE_GET(TextLab,int,1,( this->textlab[axis] == -1 ? 1 : this->textlab[axis] ),0)
MAKE_TEST(TextLab,( this->textlab[axis] != -1 ),0)
MAKE_SET(TextLab,int,textlab,( value ? 1 : 0 ),0)

MAKE_GET3(TextLab,int,1,this->utxtlb[axis],0)
MAKE_SET3(TextLab,int,utxtlb,( value ? 1 : 0 ),0)

/* TextLabGap. */
/* ----------- */
/*
*att++
*  Name:
*     TextLabGap(axis)

*  Purpose:
*     Spacing of descriptive axis labels for a Plot.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     where descriptive axis labels are placed relative to the axes they
*     describe.  It takes a separate value for each physical axis of a
*     Plot so that, for instance, the setting "TextLabGap(2)=0.01"
*     specifies where the descriptive label for the second axis should
*     be drawn.
*
*     For each axis, the TextLabGap value gives the spacing between the
*     descriptive label and a reference point specified by the TextGapType
*     attribute (by default, the edge of a box enclosing all other parts
*     of the annotated grid, excluding other descriptive labels). The gap
*     is measured to the nearest edge of the label (i.e. the top or the
*     bottom). Positive values cause the descriptive label to be placed
*     outside the bounding box, while negative values cause it to be placed
*     inside.
*
*     The TextLabGap value should be given as a fraction of the minimum
*     dimension of the plotting area, the default value depends on the
*     value of attribute TextGapType: if TextGapType is "box", the
*     default is +0.01, otherwise the default is +0.07.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - If drawn, descriptive labels are always placed at the edges of
*     the plotting area, even although the corresponding numerical
*     labels may be drawn along axis lines in the interior of the
*     plotting area (see the Labelling attribute).
*     - If no axis is specified, (e.g. "TextLabGap" instead of
*     "TextLabGap(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the TextLabGap(1) value.
*att--
*/
/* Fractional spacing between numeric labels and axes. Has a value of AST__BAD
when not set yielding a default value of 0.01 or 0.07. */
MAKE_CLEAR(TextLabGap,textlabgap,AST__BAD,0)
MAKE_GET(TextLabGap,double,0.0,( this->textlabgap[ axis ] == AST__BAD ? (astGetTextGapType(this)?0.07:0.01):this->textlabgap[axis]),0)
MAKE_SET(TextLabGap,double,textlabgap,value,0)
MAKE_TEST(TextLabGap,( this->textlabgap[axis] != AST__BAD ),0)

/* LabelUnits. */
/* ----------- */
/*
*att++
*  Name:
*     LabelUnits(axis)

*  Purpose:
*     Use axis unit descriptions in a Plot?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute controls the appearance of an annotated
c     coordinate grid (drawn with the astGrid function) by determining
f     coordinate grid (drawn with the AST_GRID routine) by determining
*     whether the descriptive labels drawn for each axis of a Plot
*     should include a description of the units being used on the
*     axis.  It takes a separate value for each physical axis of a
*     Plot so that, for instance, the setting "LabelUnits(2)=1"
*     specifies that a unit description should be included in the
*     label for the second axis.
*
*     If the LabelUnits value of a Plot axis is non-zero, a unit
*     description will be included in the descriptive label for that
*     axis, otherwise it will be omitted.  The default behaviour is to
*     include a unit description unless the current Frame of the Plot
*     is a SkyFrame representing equatorial, ecliptic, galactic or
*     supergalactic coordinates, in which case it is omitted.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - The text used for the unit description is obtained from the
*     Plot's Unit(axis) attribute.
*     - If no axis is specified, (e.g. "LabelUnits" instead of
*     "LabelUnits(2)"), then a "set" or "clear" operation will affect
*     the attribute value of all the Plot axes, while a "get" or
*     "test" operation will use just the LabelUnits(1) value.
*     - If the current Frame of the Plot is not a SkyFrame, but includes
*     axes which were extracted from a SkyFrame, then the default behaviour
*     is to include a unit description only for those axes which were not
*     extracted from a SkyFrame.
*att--
*/
/* Are textual labels to include a string describing the axis units? Has a
value of -1 when not set yielding a default of 1. */
MAKE_CLEAR(LabelUnits,labelunits,-1,0)
MAKE_TEST(LabelUnits,( this->labelunits[axis] != -1 ),0)
MAKE_SET(LabelUnits,int,labelunits,( value ? 1 : 0 ),0)

MAKE_GET3(LabelUnits,int,1,this->ulbunit[axis],0)
MAKE_SET3(LabelUnits,int,ulbunit,( value ? 1 : 0 ),0)

/* Style. */
/* ------ */
/*
*att++
*  Name:
*     Style(element)

*  Purpose:
*     Line style for a Plot element.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer.

*  Description:
*     This attribute determines the line style used when drawing each
*     element of graphical output produced by a Plot. It takes a
*     separate value for each graphical element so that, for instance,
*     the setting "Style(border)=2" causes the Plot border to be drawn
*     using line style 2 (which might result in, say, a dashed line).
*
*     The range of integer line styles available and their appearance
*     is determined by the underlying graphics system.  The default
*     behaviour is for all graphical elements to be drawn using the
*     default line style supplied by this graphics system (normally,
*     this is likely to give a solid line).

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - For a list of the graphical elements available, see the
*     description of the Plot class.
*     - If no graphical element is specified, (e.g. "Style" instead of
*     "Style(border)"), then a "set" or "clear" operation will affect
*     the attribute value of all graphical elements, while a "get" or
*     "test" operation will use just the Style(Border) value.
*att--
*/
/* Line styles. Has a value of -1 when not set yielding a default of 1. */
MAKE_CLEAR(Style,style,-1,AST__NPID)
MAKE_GET(Style,int,1,( this->style[axis] == -1 ? 1 : this->style[axis] ),AST__NPID)
MAKE_TEST(Style,( this->style[axis] != -1 ),AST__NPID)
MAKE_SET(Style,int,style,value,AST__NPID)

/* Font. */
/* ----- */
/*
*att++
*  Name:
*     Font(element)

*  Purpose:
*     Character font for a Plot element.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer.

*  Description:
*     This attribute determines the character font index used when
*     drawing each element of graphical output produced by a Plot. It
*     takes a separate value for each graphical element so that, for
*     instance, the setting "Font(title)=2" causes the Plot title to
*     be drawn using font number 2.
*
*     The range of integer font indices available and the appearance
*     of the resulting text is determined by the underlying graphics
*     system.  The default behaviour is for all graphical elements to
*     be drawn using the default font supplied by this graphics
*     system.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - For a list of the graphical elements available, see the
*     description of the Plot class.
*     - If no graphical element is specified, (e.g. "Font" instead
*     of "Font(title)"), then a "set" or "clear" operation will
*     affect the attribute value of all graphical elements, while a
*     "get" or "test" operation will use just the Font(TextLab)
*     value.
*att--
*/
/* Character fonts. Has a value of -1 when not set yielding a default of 1. */
MAKE_CLEAR(Font,font,-1,AST__NPID)
MAKE_GET(Font,int,1,( this->font[axis] == -1 ? 1 : this->font[axis] ),AST__NPID)
MAKE_TEST(Font,( this->font[axis] != -1 ),AST__NPID)
MAKE_SET(Font,int,font,value,AST__NPID)

/* Colour. */
/* ------- */
/*
*att++
*  Name:
*     Colour(element)

*  Purpose:
*     Colour index for a Plot element.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer.

*  Description:
*     This attribute determines the colour index used when drawing
*     each element of graphical output produced by a Plot. It takes a
*     separate value for each graphical element so that, for instance,
*     the setting "Colour(title)=2" causes the Plot title to be drawn
*     using colour index 2. The synonym "Color" may also be used.
*
*     The range of integer colour indices available and their
*     appearance is determined by the underlying graphics system. The
*     default behaviour is for all graphical elements to be drawn
*     using the default colour index supplied by this graphics system
*     (normally, this is likely to result in white plotting on a black
*     background, or vice versa).
d
*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - For a list of the graphical elements available, see the
*     description of the Plot class.
*     - If no graphical element is specified, (e.g. "Colour" instead
*     of "Colour(title)"), then a "set" or "clear" operation will
*     affect the attribute value of all graphical elements, while a
*     "get" or "test" operation will use just the Colour(TextLab)
*     value.
*att--
*/
/* Colours. Has a value of -1 when not set yielding a default of 1. */
MAKE_CLEAR(Colour,colour,-1,AST__NPID)
MAKE_GET(Colour,int,1,( this->colour[axis] == -1 ? 1 : this->colour[axis] ),AST__NPID)
MAKE_TEST(Colour,( this->colour[axis] != -1 ),AST__NPID)
MAKE_SET(Colour,int,colour,value,AST__NPID)

/* Width. */
/* ------ */
/*
*att++
*  Name:
*     Width(element)

*  Purpose:
*     Line width for a Plot element.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating point.

*  Description:
*     This attribute determines the line width used when drawing each
*     element of graphical output produced by a Plot.  It takes a
*     separate value for each graphical element so that, for instance,
*     the setting "Width(border)=2.0" causes the Plot border to be
*     drawn using a line width of 2.0. A value of 1.0 results in a
*     line thickness which is approximately 0.0005 times the length of
*     the diagonal of the entire display surface.
*
*     The actual appearance of lines drawn with any particular width,
*     and the range of available widths, is determined by the
*     underlying graphics system.  The default behaviour is for all
*     graphical elements to be drawn using the default line width
*     supplied by this graphics system. This will not necessarily
*     correspond to a Width value of 1.0.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - For a list of the graphical elements available, see the
*     description of the Plot class.
*     - If no graphical element is specified, (e.g. "Width" instead of
*     "Width(border)"), then a "set" or "clear" operation will affect
*     the attribute value of all graphical elements, while a "get" or
*     "test" operation will use just the Width(Border) value.
*att--
*/
/* Line widths. Has a value of AST__BAD when not set yielding a
   default of 1.0. */
MAKE_CLEAR(Width,width,AST__BAD,AST__NPID)
MAKE_GET(Width,double,1.0,( this->width[axis] == AST__BAD ? 1.0 : this->width[axis] ),AST__NPID)
MAKE_TEST(Width,( this->width[axis] != AST__BAD ),AST__NPID)
MAKE_SET(Width,double,width,(value!=0.00)?value:(astError(AST__ATTIN,"astSetWidth(Plot):Invalid zero value supplied for Width(%s) attribute", status,GrfItem(axis,NULL,NULL, status )),this->width[axis]),AST__NPID)

/* Size. */
/* ----- */
/*
*att++
*  Name:
*     Size(element)

*  Purpose:
*     Character size for a Plot element.

*  Type:
*     Public attribute.

*  Synopsis:
*     Floating Point.

*  Description:
*     This attribute determines the character size used when drawing
*     each element of graphical output produced by a Plot. It takes a
*     separate value for each graphical element so that, for instance,
*     the setting "Size(title)=2.0" causes the Plot title to be drawn
*     using twice the default character size.
*
*     The range of character sizes available and the appearance of the
*     resulting text is determined by the underlying graphics system.
*     The default behaviour is for all graphical elements to be drawn
*     using the default character size supplied by this graphics
*     system.

*  Applicability:
*     Plot
*        All Plots have this attribute.

*  Notes:
*     - For a list of the graphical elements available, see the
*     description of the Plot class.
*     - If no graphical element is specified, (e.g. "Size" instead
*     of "Size(title)"), then a "set" or "clear" operation will
*     affect the attribute value of all graphical elements, while a
*     "get" or "test" operation will use just the Size(TextLab)
*     value.
*att--
*/
/* Character sizes. Has a value of AST__BAD when not set yielding a default
   of 1.0. */
MAKE_CLEAR(Size,size,AST__BAD,AST__NPID)
MAKE_GET(Size,double,1.0,( this->size[axis] == AST__BAD ? 1.0 : this->size[axis] ),AST__NPID)
MAKE_TEST(Size,( this->size[axis] != AST__BAD ),AST__NPID)
MAKE_SET(Size,double,size,(value!=0.00)?value:(astError(AST__ATTIN,"astSetSize(Plot): Invalid zero value supplied for Size(%s) attribute", status,GrfItem(axis,NULL,NULL, status )),this->size[axis]),AST__NPID)

/* Member functions. */
/* ================= */
static void AddCdt( AstPlotCurveData *cdt1, AstPlotCurveData *cdt2, const char *method,
                    const char *class, int *status ){
/*
*
*  Name:
*     AddCdt

*  Purpose:
*     Append one AstPlotCurveData structure to another.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void AddCdt( AstPlotCurveData *cdt1, AstPlotCurveData *cdt2, const char *method,
*                  const char *class, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     The contents of the structure pointed to by "cdt2" is appended
*     to the structure pointed to by "cdt1".

*  Parameters:
*     cdt1
*        Pointer to the AstPlotCurveData structure to be modified.
*     cdt2
*        Pointer to the AstPlotCurveData structure to be appended to cdt1.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  An error is reported if there is insufficient room in "cdt1" to
*     store the information in "cdt2".

*/

/* Local Variables: */
   int nbrk, i, j;

/* Check the global error status. */
   if ( !astOK ) return;

/* Get the total number of breaks described by both structures. */
   nbrk = cdt1->nbrk + cdt2->nbrk;

/* Report an error if this number of breaks cannot be stored in a AstPlotCurveData
   structure. */
   if( nbrk > AST__MXBRK ){
      astError( AST__CVBRK, "%s(%s): Number of breaks in curve "
                "exceeds %d.", status, method, class, AST__MXBRK );

/* Otherwise, append the information. */
   } else {

/* Store the index within "cdt1" of the next break to be added. */
      j = cdt1->nbrk;

/* Add each the position and direction information for each of the breaks
   in "cdt2". */
      for( i = 0; i < cdt2->nbrk; i++ ){
         cdt1->xbrk[ j ] = cdt2->xbrk[ i ];
         cdt1->ybrk[ j ] = cdt2->ybrk[ i ];
         cdt1->vxbrk[ j ] = cdt2->vxbrk[ i ];
         cdt1->vybrk[ j ] = cdt2->vybrk[ i ];

/* Increment the index of the next break in "cdt1". */
         j++;
      }

/* Update the number of breaks in "cdt1". */
      cdt1->nbrk = nbrk;

/* Update the length of the curve described by "cdt1". */
      cdt1->length += cdt2->length;

/* Update the flag indicating if the entire curve is outside the plotting
   zone. */
      if( !cdt2->out ) cdt1->out = 0;

   }

/* Return. */
   return;

}

static void Apoly( AstPlot *this, float x, float y, int *status ){
/*
*  Name:
*     Apoly

*  Purpose:
*     Append a another point to a poly line.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Apoly( AstPlot *this, float x, float y, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function appends the supplied point to the current poly line.

*  Parameters:
*     x
*        The graphics x coordinate.
*     y
*        The graphics y coordinate.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int ipoint;
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */

/* Check the global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Extend the buffers, and add the supplied point to the end. */
   ipoint = Poly_n++;
   Poly_x = astGrow( Poly_x, Poly_n, sizeof(*Poly_x) );
   Poly_y = astGrow( Poly_y, Poly_n, sizeof(*Poly_y) );
   if( astOK ) {
      Poly_x[ ipoint ] = x;
      Poly_y[ ipoint ] = y;
   }

/* Update the box containing all plotted lines. */
   Box_lbnd[ 0 ] = astMIN( x, Box_lbnd[ 0 ] );
   Box_ubnd[ 0 ] = astMAX( x, Box_ubnd[ 0 ] );
   Box_lbnd[ 1 ] = astMIN( y, Box_lbnd[ 1 ] );
   Box_ubnd[ 1 ] = astMAX( y, Box_ubnd[ 1 ] );

}

static void AxPlot( AstPlot *this, int axis, const double *start, double length,
                    int ink, AstPlotCurveData *cdata, const char *method, const char *class, int *status ){
/*
*
*  Name:
*     AxPlot

*  Purpose:
*     Draw a curve with constant axis value.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void AxPlot( AstPlot *this, int axis, const double *start, double length,
*                  int ink, AstPlotCurveData *cdata, const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws a section of a curve of the specified length
*     with constant value on a specified axis in the current Frame of the
*     Plot, starting at the specified position. The algorithm used can handle
*     discontinuities in the Mapping between the current Frame and graphics
*     coordinates, and information describing any breaks in the curve
*     (including the start and end of the curve) are returned in the supplied
*     AstPlotCurveData structure.

*  Parameters:
*     this
*        Pointer to the Plot.
*     axis
*        The zero-based index of an axis within the current Frame of the Plot.
*        The curve has a varying value on this axis.
*     start
*        A pointer to a an array holding the coordinates of the start of the
*        curve within the current Frame of the Plot.
*     length
*        The length of the section of the curve to be drawn, given as an
*        increment along the axis specified by parameter "axis".
*     ink
*        If zero, the curve is not actually drawn, but information about
*        the breaks is still returned. If non-zero, the curve is also drawn.
*     cdata
*        A pointer to a structure in which to return information about the
*        breaks in the curve.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  No curve is draw if the "start" array contains any bad values
*     (i.e. values equal to AST__BAD), or if the "length" value is bad,
*     or if a NULL pointer is supplied for "cdata". No errors are reported
*     in these cases.
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   double d[ CRV_NPNT ];   /* Offsets to evenly spaced points along curve */
   double x[ CRV_NPNT ];   /* X coords at evenly spaced points along curve */
   double y[ CRV_NPNT ];   /* Y coords at evenly spaced points along curve */
   double tol;             /* Absolute tolerance value */
   int i;                  /* Loop count */
   int naxes;              /* No. of axes in the base Frame */
   int ok;                 /* Are all start coords good? */
   int gridid;             /* Identifier value for element being drawn */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

#ifdef CRV_TRACE
   printf("AXPLOT: axis %d, start (%.*g,%.*g), length %.*g\n",
          axis, AST__DBL_DIG, start[0], AST__DBL_DIG, start[1], AST__DBL_DIG, length );
   getchar();
#endif


/* Initialise any supplied cdata structure to hold safe values. */
   if( cdata ){
      cdata->length = 0.0;
      cdata->out = 1;
      cdata->nbrk = 0;
   }

/* Get the number of axes in the current Frame. */
   naxes = astGetNout( this );

/* Check the "start" parameter for bad values. */
   ok = 1;
   for( i = 0; i < naxes; i++ ) {
      if( start[ i ] == AST__BAD ){
         ok = 0;
         break;
      }
   }

/* Check the "length" parameter for bad values. */
   if( length == AST__BAD ) ok = 0;

/* Check that the "cdata" pointer can be used. */
   if( !cdata ) ok = 0;

/* Only proceed if the parameters are OK, and there has been no error. */
   if( ok && astOK ){

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
      if( axis == 0 ) {
         gridid = AST__GRIDLINE2_ID;
      } else {
         gridid = AST__GRIDLINE1_ID;
      }
      astGrfAttrs( this, gridid, 1, GRF__LINE, method, class );

/* Ensure the globals holding the scaling from graphics coords to equally
   scaled coords are available. */
      GScales( this, NULL, NULL, method, class, status );

/* Set up the externals used to communicate with the Map1 function...
   The number of axes in the physical coordinate system (i.e. the current
   Frame). */
      Map1_ncoord = naxes;

/* See if tick marks are logarithmically or linearly spaced. */
      Map1_log = astGetLogTicks( this, axis );

/* A pointer to the Plot, the Current Frame and the Mapping. */
      Map1_plot = this;
      Map1_frame = astGetFrame( this, AST__CURRENT );
      Map1_map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Physical coords at the start of the curve (dist=0). */
      Map1_origin = start;

/* Length of the curve. */
      Map1_length = length;

/* The index of the axis which the curve follows. */
      Map1_axis = axis;

/* Decide whether to omit points not in their normal ranges. */
      Map1_norm = !IsASkyAxis( Map1_frame, 0, status ) &&
                  !IsASkyAxis( Map1_frame, 1, status );

/* Convert the tolerance from relative to absolute graphics coordinates. */
      tol = astGetTol( this )*astMAX( this->xhi - this->xlo,
                                   this->yhi - this->ylo );

/* Now set up the external variables used by the Crv and CrvLine function. */
      Crv_scerr = ( astGetLogPlot( this, 0 ) ||
                    astGetLogPlot( this, 1 ) ) ? 100.0 : 1.5;
      Crv_ux0 = AST__BAD;
      Crv_tol = tol;
      Crv_limit = 0.5*tol*tol;
      Crv_map = Map1;
      Crv_ink = ink;
      Crv_xlo = this->xlo;
      Crv_xhi = this->xhi;
      Crv_ylo = this->ylo;
      Crv_yhi = this->yhi;
      Crv_out = 1;
      Crv_xbrk = cdata->xbrk;
      Crv_ybrk = cdata->ybrk;
      Crv_vxbrk = cdata->vxbrk;
      Crv_vybrk = cdata->vybrk;
      Crv_clip = astGetClip( this ) & 1;

/* Set up a list of points spread evenly over the curve. */
      for( i = 0; i < CRV_NPNT; i++ ){
        d[ i ] = ( (double) i)/( (double) CRV_NSEG );
      }

/* Map these points into graphics coordinates. */
      Map1( CRV_NPNT, d, x, y, method, class, status GLOBALS_NAME );

/* Use Crv and Map1 to draw the curve. */
      Crv( this, d, x, y, 0, NULL, NULL, method, class, status );

/* End the current poly line. */
      Opoly( this, status );

/* Tidy up the static data used by Map1. */
      Map1( 0, NULL, NULL, NULL, method, class, status GLOBALS_NAME );

/* If no part of the curve could be drawn, set the number of breaks and the
   length of the drawn curve to zero. */
      if( Crv_out ) {
         Crv_nbrk = 0;
         Crv_len = 0.0F;

/* Otherwise, add an extra break to the returned structure at the position of
   the last point to be plotted. */
      } else {
         Crv_nbrk++;
         if( Crv_nbrk > AST__PLOT_CRV_MXBRK ){
            astError( AST__CVBRK, "%s(%s): Number of breaks in curve "
                      "exceeds %d.", status, method, class, AST__PLOT_CRV_MXBRK );
         } else {
            *(Crv_xbrk++) = (float) Crv_xl;
            *(Crv_ybrk++) = (float) Crv_yl;
            *(Crv_vxbrk++) = (float) -Crv_vxl;
            *(Crv_vybrk++) = (float) -Crv_vyl;
         }
      }

/* Store extra information about the curve in the returned structure, and
   purge any zero length sections. */
      if( cdata ){
         cdata->length = Crv_len;
         cdata->out = Crv_out;
         cdata->nbrk = Crv_nbrk;
         PurgeCdata( cdata, status );
      }

/* Annul the Frame and Mapping. */
      Map1_frame = astAnnul( Map1_frame );
      Map1_map = astAnnul( Map1_map );

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, gridid, 0, GRF__LINE, method, class );

   }

/* Return. */
   return;

}

static void BBuf( AstPlot *this, int *status ) {
/*
*++
*  Name:
c     astBBuf
f     AST_BBUF

*  Purpose:
*     Begin a new graphical buffering context.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     void astBBuf( AstPlot *this )
f     CALL AST_BBUF( THIS STATUS )

*  Class Membership:
*     Plot member function.

*  Description:
c     This function
f     This routine
*     starts a new graphics buffering context. A matching call to the
c     function astEBuf
f     routine AST_EBUF
*     should be used to end the context.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - The nature of the buffering is determined by the underlying
*     graphics system (as defined by the current grf module). Each call
c     to this function
f     to this routine
c     to this function
f     to this routine
*     simply invokes the astGBBuf function in the grf module.

*--
*/

/* Check the global error status. */
   if ( !astOK ) return;

/* Invoke the active GRF BBuf function. */
   GBBuf( this, "astBBuf", astGetClass( this ), status );

}

static int Boundary( AstPlot *this, const char *method, const char *class, int *status ){
/*
*  Name:
*     Boundary

*  Purpose:
*     Draw a boundary around regions containing valid physical positions.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Boundary( AstPlot *this, const char *method, const char *class, int *status  )

*  Class Membership:
*     Plot method.

*  Description:
*     This function draws a boundary around the regions of the plotting
*     area which contain valid, unclipped, physical coordinates, but does
*     not include the intersections with the edges of the plotting area.
*
*     Broadly, the algorithm is as follows: An initial coarse grid is
*     created covering the entire plotting area. This grid consists of a
*     regular square matrix of points in graphics coordinates, and the
*     corresponding physical coordinates. An array of flags is created,
*     one for each grid cell, indicating if the boundary passes through the
*     cell. This is assumed to be the case if the cell has a mix of good and
*     bad corners (i.e corners which have good or bad physical coordinates).
*     This assumption does not locate all boundary cells though, since if
*     the boundary passes into and out of a cell throught the same edge,
*     the corners of the cell will be either all good or all bad. But for
*     the moment, we just concentrate on the ones found using this simple
*     assumption. For each such cell, a finer grid is then created covering
*     the cell, and the boundary is drawn through this fine grid using
*     TraceBorder. TraceBorder returns a set of four flags indicating which
*     edges of the cell were intersected by the boundary. A check is then
*     made on any of the four neighbouring cells into which the curve
*     passes. If any of these cells were not flagged as boundary cells using
*     the simple assumption described earlier, then they are flagged now
*     (with a different flag value). Once all the cells located using the
*     simple assumption have been processed, any further cells flagged
*     with the new flag value are also processed using TraceBorder in the
*     same way. This process is repeated until no extra boundary cells are
*     found.

*  Parameters:
*     this
*        Pointer to a Plot.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A flag indicating if any regions containing invalid physical
*     coordinates were found within the plotting area.

*  Notes:
*     -  This function assumes the physical coordinate Frame is
*     2-dimensional, and it should not be used if this is not the case.
*     -  A value of zero is returned if an error has already occurred, or
*     if this function should fail for any reason.

*/

/* Local Variables: */
   AstFrame *bfrm;         /* Pointer to base Plot Frame */
   AstFrame *cfrm;         /* Pointer to current Plot Frame */
   AstMapping *map;        /* Pointer to Plot mapping (graphics -> physical) */
   AstMapping *rmap;       /* Pointer to Plot mapping (graphics -> physical) */
   AstRegion *breg;        /* Region mapped into base Plot Frame */
   double blbnd[ 2 ];      /* Lower grid bounds in base frame */
   double bubnd[ 2 ];      /* Upper grid bounds in base frame */
   double dx;              /* Plotting area width */
   double dy;              /* Plotting area height */
   double power;           /* Exponent in pow call */
   double rat;             /* Ratio by which to reduce DIM */
   double tol;             /* Fractional plotting tolerance */
   int dim;                /* No. of points along each edge of coarse grid */
   int edges[ 4 ];         /* Flags indicating edges bisected by boundary */
   int rate_disabled;      /* Was the astRate method initially disabled? */
   int ret;                /* Any regions containing bad physical coords? */

/* Check global status. */
   if( !astOK ) return 0;

/* Initialise the answer to indicate that no regions containing invalid
   physical coordinates have been found. */
   ret = 0;

/* Get the current Frame from the Plot. */
   cfrm = astGetFrame( this, AST__CURRENT );

/* If it is a region, we use a special method, if possible, to trace the
   Region boundary. Otherwise, we use a grid tracing method that makes no
   assumptions about the nature of the Mapping or Frame. */
   if( !DrawRegion( this, cfrm, method, class, status ) ) {

/* Each basic element of the boundary drawn by the following algorithm
   will be drawn at a multiple of 45 degrees to the horizontal. This can
   cause noticable aliasing. For instance, if the border is a straight
   line at 50 degrees to the horizontal, it will be drawn at 45 degrees
   for long sections, followed by a vertical leap to catch up with where
   it should be. Because of this we use a finer tolerance than for other
   drawing. */
      tol = 0.25*astGetTol( this );

/* Set up the dimension of a coarse grid in graphics coordinates to cover the
   whole plotting area. This is chosen to give a finer grid for smaller
   plotting tolerances. Note, putting the power as a literal constant in
   the call to pow seems to cause a segmentation violation on some systems. */
      power = -0.666666666;
      dim = (int) 4*pow( tol, power ) + 10;
      if( dim > 400 ) dim = 400;
      if( dim < 3 ) dim = 3;

/* Store the required plotting tolerance as a distance in graphics
   coords. */
      dx = fabs( this->xhi - this->xlo );
      dy = fabs( this->xhi - this->xlo );
      tol *= ( ( dx > dy ) ? dx : dy );

/* Extract the Mapping from the Plot. */
      map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Select the area covered by the coarse grid. If the current Frame is a
   Region, we use the bounding box of Region after being mapped into
   graphics coords. */
      if( astIsARegion( cfrm ) ) {
         bfrm = astGetFrame( this, AST__BASE );

/* Get the Mapping from the current to the base Frame in the Plot, and
   remove the effects of any Regions. */

         astInvert( map );
         rmap = astRemoveRegions( map );
         astInvert( map );

/* Map the Region into the GRAPHICS frame. */
         breg = astMapRegion( cfrm, rmap, bfrm );
         astGetRegionBounds( breg, blbnd, bubnd );

         rmap = astAnnul( rmap );
         bfrm = astAnnul( bfrm );
         breg = astAnnul( breg );

         rat = ( ( bubnd[ 0 ] - blbnd[ 0 ] )*( bubnd[ 1 ] - blbnd[ 1 ] ) )/
               ( ( this->xhi - this->xlo )*( this->yhi - this->ylo ) );
         rat = sqrt( rat );
         dim = (int) ( rat*dim );
         if( dim < 3 ) dim = 3;
         if( dim > 2000 ) dim = 2000;

/* If the current Frame is not a Region, use the whole plot. */
      } else {
         blbnd[ 0 ] = this->xlo;
         blbnd[ 1 ] = this->ylo;
         bubnd[ 0 ] = this->xhi;
         bubnd[ 1 ] = this->yhi;
      }

/* Disable the astRate method in order to improve the speed of
   evaluating the Mapping in cases where the Mapping includes an
   AstRateMap. Note the original value of the flag so that it can be
   re-instated at the end. */
      rate_disabled = astRateState( 1 );

/* Draw the boundary. */
      ret = TraceBorder( this, map, blbnd[ 0 ], bubnd[ 0 ], blbnd[ 1 ],
                         bubnd[ 1 ], dim, tol, edges, method, class, status );

/* Re-instate the original setting of the "astRate disabled" flag. */
      astRateState( rate_disabled );

/* Release the remaining resources. */
      map = astAnnul( map );
   }
   cfrm = astAnnul( cfrm );

/* If an error has occurred, return 0. */
   if( !astOK ) ret = 0;

/* Return the answer. */
   return ret;
}

static int Border( AstPlot *this_nd, int *status ){
/*
*++
*  Name:
c     astBorder
f     AST_BORDER

*  Purpose:
*     Draw a border around valid regions of a Plot.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     int astBorder( AstPlot *this )
f     RESULT = AST_BORDER( THIS, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
*     This function draws a (line) border around regions of the
*     plotting area of a Plot which correspond to valid, unclipped
*     physical coordinates. For example, when plotting using an
*     all-sky map projection, this function could be used to draw the
*     boundary of the celestial sphere when it is projected on to the
*     plotting surface.
*
*     If the entire plotting area contains valid, unclipped physical
*     coordinates, then the boundary will just be a rectangular box
*     around the edges of the plotting area.
*
*     If the Plot is a Plot3D, this method is applied individually to
*     each of the three 2D Plots encapsulated within the Plot3D (each of
*     these Plots corresponds to a single 2D plane in the 3D graphics
*     system). In addition, if the entire plotting volume has valid
*     coordinates in the 3D current Frame of the Plot3D, then additional
*     lines are drawn along the edges of the 3D plotting volume so that
*     the entire plotting volume is enclosed within a cuboid grid.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astBorder()
f     AST_BORDER = LOGICAL
c        Zero is returned if the plotting space is completely filled by
f        .FALSE. is returned if the plotting space is completely filled by
*        valid, unclipped physical coordinates (so that only a
c        rectangular box was drawn around the edge). Otherwise, one is
f        rectangular box was drawn around the edge). Otherwise, .TRUE. is
*        returned.

*  Notes:
c     - A value of zero will be returned if this function is invoked
f     - A value of .FALSE. will be returned if this function is invoked
c     with the AST error status set, or if it should fail for any
f     with STATUS set to an error value, or if it should fail for any
*     reason.
*     - An error results if either the current Frame or the base Frame
*     of the Plot is not 2-dimensional or (for a Plot3D) 3-dimensional.
*     - An error also results if the transformation between the base
*     and current Frames of the Plot is not defined (i.e. the Plot's
*     TranForward attribute is zero).
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   AstPlot *this;          /* Plot with no more than 2 current axes */
   AstPlotCurveData cdata; /* Structure to receive break information */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   int inval;              /* Were any bad regions found? */
   int naxes;              /* No. of axes in the base Frame */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this_nd);

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astBorder";
   class = astGetClass( this_nd );

/* Initialise the bounding box for primitives produced by this call. */
   if( !Boxp_freeze ) {
      Boxp_lbnd[ 0 ] = FLT_MAX;
      Boxp_lbnd[ 1 ] = FLT_MAX;
      Boxp_ubnd[ 0 ] = FLT_MIN;
      Boxp_ubnd[ 1 ] = FLT_MIN;
   }

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this_nd );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Get a Plot with a 2D (or 1D) current Frame. */
   this = (AstPlot *) Fset2D( (AstFrameSet *) this_nd, AST__CURRENT, status );

/* Check the current Frame of the Plot is 2-D. */
   naxes = astGetNout( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the current "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
   astGrfAttrs( this, AST__BORDER_ID, 1, GRF__LINE, method, class );

/* We first draw the intersections of the regions containing valid
   physical coordinates with the edges of the plotting area. First do
   the bottom edge. */
   LinePlot( this, this->xlo, this->ylo, this->xhi, this->ylo,
             1, &cdata, method, class, status );

/* Now do the right-hand edge. */
   LinePlot( this, this->xhi, this->ylo, this->xhi, this->yhi,
             1, &cdata, method, class, status );

/* Now do the top edge. */
   LinePlot( this, this->xhi, this->yhi, this->xlo, this->yhi,
             1, &cdata, method, class, status );

/* Now do the left-hand edge. */
   LinePlot( this, this->xlo, this->yhi, this->xlo, this->ylo,
             1, &cdata, method, class, status );

/* Now draw a curve following the boundary through the interior of the
   plotting area. If the current Frame in the Plot is a Region, we use a
   shorter method if possible. If this is not possible, we use a longer
   method. */
   inval = Boundary( this, method, class, status );

/* Ensure all lines are flushed to the graphics system. */
   Fpoly( this, method, class, status );

/* Re-establish the original graphical attributes. */
   astGrfAttrs( this, AST__BORDER_ID, 0, GRF__LINE, method, class );

/* Annul the 2d plot. */
   this = astAnnul( this );

/* Return. */
   return inval;

}

static void BoundingBox( AstPlot *this, float lbnd[2], float ubnd[2], int *status ){
/*
*++
*  Name:
c     astBoundingBox
f     AST_BOUNDINGBOX

*  Purpose:
*     Return a bounding box for previously drawn graphics.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astBoundingBox( AstPlot *this, float lbnd[2], float ubnd[2] )
f     CALL AST_BOUNDINGBOX( THIS, LBND, UBND, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function returns the bounds of a box which just encompasess the
f     This routine returns the bounds of a box which just encompasess the
*     graphics produced by the previous call to any of the Plot methods
*     which produce graphical output. If no such previous call has yet
*     been made, or if the call failed for any reason, then the bounding box
c     returned by this function is undefined.
f     returned by this routine is undefined.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     lbnd
f     LBND( 2 ) = REAL (Returned)
*        A two element array in which is returned the lower limits of the
*        bounding box on each of the two axes of the graphics coordinate
*        system (the base Frame of the Plot).
c     ubnd
f     UBND( 2 ) = REAL (Returned)
*        A two element array in which is returned the upper limits of the
*        bounding box on each of the two axes of the graphics coordinate
*        system (the base Frame of the Plot).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - An error results if the base Frame of the Plot is not
*     2-dimensional.
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   AstFrameSet *fset;      /* Pointer to the Plot's FrameSet */
   int naxes;              /* No. of axes in the base Frame */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Get a pointer to the FrameSet at the start of the Plot. */
   fset = (AstFrameSet *) this;

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( fset );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "astBoundingBox(%s): Number of axes (%d) in the "
                "base Frame of the supplied %s is invalid - this number "
                "should be 2.", status, astGetClass( this ), naxes,
                astGetClass( this ) );
   }

/* Return the bounding box. */
   lbnd[ 0 ] = Boxp_lbnd[ 0 ];
   lbnd[ 1 ] = Boxp_lbnd[ 1 ];
   ubnd[ 0 ] = Boxp_ubnd[ 0 ];
   ubnd[ 1 ] = Boxp_ubnd[ 1 ];

/* Return. */
   return;

}

static int BoxCheck( float *bx, float *by, float *cx, float *cy, int *status ) {
/*
*  Name:
*     BoxCheck

*  Purpose:
*     See if two boxes overlap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int BoxCheck( float *bx, float *by, float *cx, float *cy, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function returns a flag indicating if two trapezoidal boxes
*     (box "b" and box "c") overlap or not.

*  Parameters:
*     bx
*        Pointer to an array holding the X coordinates at the 4 corners
*        of box "b".
*     by
*        Pointer to an array holding the Y coordinates at the 4 corners
*        of box "b".
*     cx
*        Pointer to an array holding the X coordinates at the 4 corners
*        of box "c".
*     cy
*        Pointer to an array holding the Y coordinates at the 4 corners
*        of box "c".
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Zero is returned if the boxes do not overlap or an error has
*     already occurred. Otherwise, 1 is returned.

*/

/* Local Variables: */
   float x2;
   float y2;
   int i;
   int ip;
   int j;
   int jp;
   int ret;

/* Assume the boxes do not overlap. */
   ret = 0;

/* Check the inherited status. */
   if( !astOK ) return ret;

/* Check each corner of box b to see if it is inside box c. */
   for( j = 0; j < 4 && ret == 0; j++ ){
      if( Inside( 4, cx, cy, bx[ j ], by[ j ], status ) ) ret = 1;
   }

/* Now check each corner of box c to see if it is inside box b. */
   for( j = 0; j < 4 && ret == 0; j++ ){
      if( Inside( 4, bx, by, cx[ j ], cy[ j ], status ) ) ret = 1;
   }

/* If no overlap has yet been found, we need to see if any of the edges
   of the boxes intersect. For instance, in the case of a cross formed by
   a vertical rectangle crossing a horizontal rectangle, the above checks
   on the corners would not have revealed any overlap. */
   if( !ret ) {

/* The following code assumes that the corners with indices 0, 1, 2, 3
   are adjacent round the edge of the box. This is the case if the line
   joining corners 0 and 1 does not cross the line joining corners 2 and
   3 AND the line joining corners 1 and 2 does not cross the line joining
   corners 3 and 0. If either of these conditions is not met swap the
   corners around to correct it. First do box b. */
      if( Cross( bx[0], by[0], bx[1], by[1],
                 bx[2], by[2], bx[3], by[3], status ) ) {
         x2 = bx[2];
         y2 = by[2];
         bx[2] = bx[1];
         by[2] = by[1];
         bx[1] = x2;
         by[1] = y2;

      } else if( Cross( bx[1], by[1], bx[2], by[2],
                        bx[3], by[3], bx[0], by[0], status ) ) {
         x2 = bx[2];
         y2 = by[2];
         bx[2] = bx[3];
         by[2] = by[3];
         bx[3] = x2;
         by[3] = y2;
      }

/* Now do box c. */
      if( Cross( cx[0], cy[0], cx[1], cy[1],
                 cx[2], cy[2], cx[3], cy[3], status ) ) {
         x2 = cx[2];
         y2 = cy[2];
         cx[2] = cx[1];
         cy[2] = cy[1];
         cx[1] = x2;
         cy[1] = y2;

      } else if( Cross( cx[1], cy[1], cx[2], cy[2],
                        cx[3], cy[3], cx[0], cy[0], status ) ) {
         x2 = cx[2];
         y2 = cy[2];
         cx[2] = cx[3];
         cy[2] = cy[3];
         cx[3] = x2;
         cy[3] = y2;
      }

/* We now check each edge of box b to see if it overlaps any edge of box c. */
      for( j = 0; j < 4 && ret == 0; j++ ) {

/* This edge of box b starts at the corner with index j. Get the index of the
   corner at which the edge ends. */
         jp = j + 1;
         if( jp == 4 ) jp = 0;

/* Check to see if this edge of box b crosses each edge of box c in turn. */
         for( i = 0; i < 4 && ret == 0; i++ ) {
            ip = i + 1;
            if( ip == 4 ) ip = 0;

            ret = Cross( bx[j], by[j], bx[jp], by[jp],
                         cx[i], cy[i], cx[ip], cy[ip], status );

         }
      }
   }

   return ret;
}

static void Bpoly( AstPlot *this, float x, float y, int *status ){
/*
*  Name:
*     Bpoly

*  Purpose:
*     Begin a new poly line.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Bpoly( AstPlot *this, float x, float y, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws any current poly line, and then starts a new one
*     at the supplied position.

*  Parameters:
*     x
*        The graphics x coordinate.
*     y
*        The graphics y coordinate.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   int ignore;             /* Is the new point the end of the current polyline? */

/* Check the global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* See if the new point is co-incident with the end of the current
   polyline. If so we assume the current polyline is to be re-started,
   rather than starting a new polyline. */
   if( Poly_n > 0 ) {
      ignore = ( astEQUALS( Poly_x[ Poly_n - 1 ], x, 1.0E8 ) &&
                 astEQUALS( Poly_y[ Poly_n - 1 ], y, 1.0E8 ) );
   } else {
      ignore = 0;
   }

/* If the supplied point is not at the end of the current polyline, draw
   any existing poly line. This will empty the buffer. Then add the
   supplied point into the buffer. */
   if( !ignore ) {
      Opoly( this, status );
      Apoly( this, x, y, status );
   }

}


static int CGCapWrapper( AstPlot *this, int cap, int value, int *status ) {
/*
*
*  Name:
*     CGCapWrapper

*  Purpose:
*     Call a C implementation of the GCap Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGCapWrapper( AstPlot *this, int cap, int value, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GCap
*     grf function to enquire or set a graphics attribute value.

*  Parameters:
*     this
*        The Plot.
*     cap
*        The capability to be inquired aboue.
*     value
*        The value to assign to the capability.
*     status
*        Pointer to the inherited status value.

*  Returned Value:
*     Non-zero if the grf module is capabale of performing the action
*     requested by "cap".

*/
   if( !astOK ) return 0;
   return ( (AstGCapFun) this->grffun[ AST__GCAP ] )( astGrfConID(this), cap, value );
}

static int CGAttrWrapper( AstPlot *this, int attr, double value,
                          double *old_value, int prim, int *status ) {
/*
*
*  Name:
*     CGAttrWrapper

*  Purpose:
*     Call a C implementation of the GAttr Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGAttrWrapper( AstPlot *this, int attr, double value,
*                        double *old_value, int prim, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GAttr
*     grf function to enquire or set a graphics attribute value.

*  Parameters:
*     this
*        The Plot.
*     attr
*        An integer value identifying the required attribute. The
*        following symbolic values are defined in grf.h:
*
*           GRF__STYLE  - Line style.
*           GRF__WIDTH  - Line width.
*           GRF__SIZE   - Character and marker size scale factor.
*           GRF__FONT   - Character font.
*           GRF__COLOUR - Colour index.
*     value
*        A new value to store for the attribute. If this is AST__BAD
*        no value is stored.
*     old_value
*        A pointer to a double in which to return the attribute value.
*        If this is NULL, no value is returned.
*     prim
*        The sort of graphics primitive to be drawn with the new attribute.
*        Identified by the following values defined in grf.h:
*           GRF__LINE
*           GRF__MARK
*           GRF__TEXT
*     status
*        Pointer to the inherited status value.

*/
   if( !astOK ) return 0;
   return ( (AstGAttrFun) this->grffun[ AST__GATTR ] )( astGrfConID(this), attr, value, old_value, prim );
}

static int CGBBufWrapper( AstPlot *this, int *status ) {
/*
*
*  Name:
*     CGBBufWrapper

*  Purpose:
*     Call a C implementation of the GBBuf Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGBBufWrapper( AstPlot *this ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GBBuf
*     grf function to start a new graphics context.

*  Parameters:
*     this
*        The Plot.
*     status
*        Pointer to the inherited status value.

*/
   if( !astOK ) return 0;
   return ( (AstGBBufFun) this->grffun[ AST__GBBUF ])( astGrfConID(this) );
}

static int CGEBufWrapper( AstPlot *this, int *status ) {
/*
*
*  Name:
*     CGEBufWrapper

*  Purpose:
*     Call a C implementation of the GEBuf Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGEBufWrapper( AstPlot *this ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GEBuf
*     grf function to start a new graphics context.

*  Parameters:
*     this
*        The Plot.
*     status
*        Pointer to the inherited status value.

*/
   if( !astOK ) return 0;
   return ( (AstGEBufFun) this->grffun[ AST__GEBUF ])( astGrfConID(this) );
}

static int CGFlushWrapper( AstPlot *this, int *status ) {
/*
*
*  Name:
*     CGFlushWrapper

*  Purpose:
*     Call a C implementation of the GFlush Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGFlushWrapper( AstPlot *this ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GFlush
*     grf function to flush graphics.

*  Parameters:
*     this
*        The Plot.
*     status
*        Pointer to the inherited status value.

*/
   if( !astOK ) return 0;
   return ( (AstGFlushFun) this->grffun[ AST__GFLUSH ])( astGrfConID(this) );
}

static int CGLineWrapper( AstPlot *this, int n, const float *x,
                          const float *y, int *status ) {
/*
*
*  Name:
*     CGLineWrapper

*  Purpose:
*     Call a C implementation of the GLine Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGLineWrapper( AstPlot *this, int n, const float *x,
*                        const float *y, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GLine
*     grf function to draw a polyline.

*  Parameters:
*     this
*        The Plot.
*     n
*        The number of positions to be joined together.
*     x
*        A pointer to an array holding the "n" x values.
*     y
*        A pointer to an array holding the "n" y values.
*     status
*        Pointer to the inherited status variable.

*/
   if( !astOK ) return 0;
   return ( (AstGLineFun) this->grffun[ AST__GLINE ])( astGrfConID(this), n, x, y );
}

static int CGMarkWrapper( AstPlot *this, int n, const float *x,
                          const float *y, int type, int *status ) {
/*
*
*  Name:
*     CGMarkWrapper

*  Purpose:
*     Call a C implementation of the GMark Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGMarkWrapper( AstPlot *this, int n, const float *x,
*                        const float *y, int type, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GMark grf
*     function to draw markers.

*  Parameters:
*     this
*        The Plot.
*     n
*        The number of positions to be joined together.
*     x
*        A pointer to an array holding the "n" x values.
*     y
*        A pointer to an array holding the "n" y values.
*     type
*        An integer which can be used to indicate the type of marker symbol
*        required.
*     status
*        Pointer to the inherited status value.

*/
   if( !astOK ) return 0;
   return ( (AstGMarkFun) this->grffun[ AST__GMARK ])( astGrfConID(this), n, x, y, type );
}

static int CGTextWrapper( AstPlot *this, const char *text, float x, float y,
                          const char *just, float upx, float upy, int *status ) {
/*
*
*  Name:
*     CGTextWrapper

*  Purpose:
*     Call a C implementation of the GText Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGTextWrapper( AstPlot *this, const char *text, float x, float y,
*                        const char *just, float upx, float upy, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GText grf
*     function to draw a text string.

*  Parameters:
*     this
*        The Plot.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
*     upy
*        The y component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.
*     status
*        Pointer to the inherited status value.

*/
   if( !astOK ) return 0;
   return ( (AstGTextFun) this->grffun[ AST__GTEXT ])( astGrfConID(this), text, x, y, just, upx, upy );
}

static int CGTxExtWrapper( AstPlot *this, const char *text, float x, float y,
                           const char *just, float upx, float upy, float *xb,
                           float *yb, int *status ) {
/*
*
*  Name:
*     CGTxExtWrapper

*  Purpose:
*     Call a C implementation of the GTxExt Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGTxExtWrapper( AstPlot *this, const char *text, float x, float y,
*                         const char *just, float upx, float upy, float *xb,
*                         float *yb, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GTxExt
*     grf function to find the extent of a text string.

*  Parameters:
*     this
*        The Plot.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
*     upy
*        The y component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.
*     xb
*        An array of 4 elements in which to return the x coordinate of
*        each corner of the bounding box.
*     yb
*        An array of 4 elements in which to return the y coordinate of
*        each corner of the bounding box.
*     status
*        Pointer to the inherited status variable.

*/
   if( !astOK ) return 0;
   return ( (AstGTxExtFun) this->grffun[ AST__GTXEXT ])( astGrfConID(this), text, x, y, just, upx, upy, xb, yb );
}

static int CGQchWrapper( AstPlot *this, float *chv, float *chh, int *status ) {
/*
*
*  Name:
*     CGQchWrapper

*  Purpose:
*     Call a C implementation of the GQch Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGQchWrapper( AstPlot *this, float *chv, float *chh, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GQch
*     grf function to find the extent of a text string.

*  Parameters:
*     this
*        The Plot.
*     chv
*        A pointer to the double which is to receive the height of
*        characters drawn vertically. This will be an increment in the X
*        axis
*     chh
*        A pointer to the double which is to receive the height of
*        characters drawn vertically. This will be an increment in the Y
*        axis
*     status
*        Pointer to the inherited status value.
*/
   if( !astOK ) return 0;
   return ( (AstGQchFun) this->grffun[ AST__GQCH ])( astGrfConID(this), chv, chh );
}

static int CGScalesWrapper( AstPlot *this, float *alpha, float *beta, int *status ) {
/*
*
*  Name:
*     CGScalesWrapper

*  Purpose:
*     Call a C implementation of the GScales Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CGScalesWrapper( AstPlot *this, float *alpha, float *beta, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function is a wrapper for a C implementation of the GScales
*     grf function to find the extent of a text string.

*  Parameters:
*     this
*        The Plot.
*     alpha
*        A pointer to the location at which to return the scale for the
*        X axis (i.e. Xnorm = alpha*Xworld).
*     beta
*        A pointer to the location at which to return the scale for the
*        Y axis (i.e. Ynorm = beta*Yworld).
*     status
*        Pointer to the inherited status value.
*/
   if( !astOK ) return 0;
   return ( (AstGScalesFun) this->grffun[ AST__GSCALES ])( astGrfConID(this), alpha, beta );
}

static int CheckLabels( AstPlot *this, AstFrame *frame, int axis,
                        double *ticks, int nticks, int force, char **list,
                        double refval, int *status ){
/*
*  Name:
*     CheckLabels

*  Purpose:
*     Create tick mark labels and check that adjacent labels are different.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CheckLabels( AstPlot *this, AstFrame *frame, int axis, double *ticks,
*                      int nticks, int force, char **list, double refval, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function formats the supplied ticks mark values using the
*     astFormat method for the supplied Frame. Unless force is non-zero, it
*     then checks all pairs of adjacent labels. If a pair is found which are
*     identical then the memory holding the labels is released, and a value
*     of zero is returned. Otherwise, a value of one is returned, indicating
*     that adjacent labels are all different and the labels are returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     frame
*        Pointer to the Frame.
*     axis
*        The zero-based index of the axis to which the tick marks refer.
*     ticks
*        Pointer to an array holding the tick mark values.
*     nticks
*        The number of tick marks supplied by parameter "ticks".
*     force
*        If non-zero, then no check for identical adjacent labels is
*        performed, and the labels are always considered to be OK.
*     list
*        Pointer to the start of an array of pointers. Each of the
*        elements in this array receives a pointer to a string holding a
*        formatted label. Each of these strings should be freed using
*        astFree when no longer needed.
*     refval
*        A value to use for the other axis when normalizing.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Zero if any pairs of identical adjacent labels were found. One
*     otherwise.

*  Notes:
*     -  No error is reported if a pair of identical adjacent labels is
*     found.
*     -  If an error has already occurred, or if this function should
*     fail for any reason, a value of zero is returned, and the array of
*     pointers identified by "list" is filled with NULL pointers.


*/

/* Local Variables: */
   const char *label;        /* Pointer to formatted tick value */
   double val[ 2 ];          /* Workspace for normalizing */
   int i;                    /* Tick index */
   int len;                  /* Number of characters in curent label */
   int ok;                   /* The returned flag */

/* Fill the supplied label list with NULL pointers. */
   if( list ) {
      for( i = 0; i < nticks; i++ ) list[ i ] = NULL;
   }

/* Check the global status. */
   if( !astOK ) return 0;

/* Initialise the returned flag to indicate that all adjacent labels are
   different. */
   ok = 1;

/* Normalize and format the first tick mark value. */
   val[ axis ] = ticks[ 0 ];
   val[ 1 - axis ] = refval;
   astNorm( frame, val );
   label = astFormat( frame, axis, val[ axis ] );

/* Allocate memory holding a copy of the formatted value, and store a
   pointer to this copy in the list of labels. */
   if( label ){
      len = strlen( label ) + 1;
      list[ 0 ] = (char *) astStore( NULL, (void *) label, len );
   } else {
      ok = 0;
   }

/* Normalize and format each of the tick mark values in this batch. */
   for( i = 1; i < nticks && astOK && ok; i++ ){
      val[ axis ] = ticks[ i ];
      val[ 1 - axis ] = refval;
      astNorm( frame, val );
      label = astFormat( frame, axis, val[ axis ] );
      if( label ){

/* Unless checks have been supressed, compare this label with the previous
   label. If they are identical clear the returned flag. */
         if( !force && !strcmp( label, list[ i - 1 ] ) ) {
            ok = 0;

/* Allocate memory holding a copy of the label, and store a
   pointer to this copy in the list of labels. */
         } else {
            list[ i ] = (char *) astStore( NULL, (void *) label, strlen( label ) + 1 );
         }

      } else {
         ok = 0;
      }

   }

/* If two adjacent labels were identical, or an error occurred, release the
   memory used to store the labels. */
   if( !ok || !astOK ){
      for( i = 0; i < nticks; i++ ){
         if( list[ i ] ) list[ i ] = (char *) astFree( (void *) list[ i ] );
      }
   }

/* Ensure a value of zero is returned if an error has occurred. */
   if( !astOK ) ok = 0;

/* Return the answer. */
   return ok;

}

static char **CheckLabels2( AstPlot *this, AstFrame *frame, int axis,
                            double *ticks, int nticks, char **old_list,
                            double refval, int *status ){
/*
*  Name:
*     CheckLabels2

*  Purpose:
*     Check that labels cannot be shortened.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     char **CheckLabels2( AstPlot *this, AstFrame *frame, int axis,
*                          double *ticks, int nticks, char **old_list,
*                          double refval, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function formats the supplied ticks mark values using the
*     astFormat method for the supplied Frame. It then compares the labels
*     with the corresponding labels supplied in "old_list". If all of the
*     new labels are shorter than, or equal in length to, the old labels,
*     then memory is allocated to hold the new (shorter) labels, and a
*     pointer to this memory is returned. If any new label is longer than
*     the corresponding old label, then a NULL pointer is returned.
*
*     No check is performed on whether or not there are any identical
*     adjacent labels.

*  Parameters:
*     this
*        Pointer to the Plot.
*     frame
*        Pointer to the Frame.
*     axis
*        The zero-based index of the axis to which the tick marks refer.
*     ticks
*        Pointer to an array holding the tick mark values.
*     nticks
*        The number of tick marks supplied by parameter "ticks".
*     old_list
*        Pointer to the start of an array of pointers. Each of the
*        elements in this array should hold a pointer to a string holding a
*        formatted label.
*     refval
*        A value to use for the other axis when normalizing.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to an array of pointers. Each of these pointers points to
*     a text string holding a shortened label. If a complete set of
*     shortened labels could not be found (or if an error occurs), a NULL
*     pointer is returned.

*  Notes:
*     -  The memory holding the returned shortened labels should be
*     freed by cthe caller, together with the memory holding the pointers to
*     the labels.
*     -  No error is reported if a pair of identical adjacent labels is
*     found.
*     -  If an error has already occurred, or if this function should
*     fail for any reason, a value of NULL is returned.

*/

/* Local Variables: */
   char **list;              /* The returned pointer */
   const char *label;        /* Pointer to formatted tick value */
   double val[ 2 ];          /* Workspace for normalizing */
   int i;                    /* Tick index */
   int llen;                 /* Number of characters in curent label */
   int ok;                   /* Are the old labels OK to be used? */

/* Check the global status. */
   if( !astOK ) return NULL;

/* Allocate memory to hold the pointers to the new labels. */
   list = (char **) astMalloc( sizeof( char * )*(size_t) nticks );
   if( list ) {

/* Fill this array with NULLs for safety. */
      for( i = 0; i < nticks; i++ ) list[ i ] = NULL;

/* Initialise a flag to indicate that all the new labels are
   shorter than the old labels. */
      ok = 0;

/* Normalize and format each of the tick mark values in this batch. */
      for( i = 0; i < nticks && astOK; i++ ){
         val[ axis ] = ticks[ i ];
         val[ 1 - axis ] = refval;
         astNorm( frame, val );
         label = astFormat( frame, axis, val[ axis ] );
         if( label ){

/* Get the length of the new label. */
            llen = strlen( label );

/* Compare this label with the corresponding old label. If the new one is
   longer than the old one, set the flag and leave the loop. */
            if( llen > strlen( old_list[ i ] ) ) {
               ok = 1;
               break;
            }

/* Store the new label. */
            list[ i ] = (char *) astStore( NULL, (void *) label,
                                           (size_t) (llen + 1) );
         }
      }

/* If the old labels are to be used, or an error occurred, release the memory
   used to store the new labels. */
      if( ok || !astOK ){
         for( i = 0; i < nticks; i++ ){
            if( list[ i ] ) list[ i ] = (char *) astFree( (void *) list[ i ] );
         }
         list = (char **) astFree( (void *) list );
      }

   }

/* Return the answer. */
   return list;

}

static int ChrLen( const char *string, int *status ){
/*
*  Name:
*     ChrLen

*  Purpose:
*     Return the length of a string excluding any trailing white space.

*  Type:
*     Private function.

*  Synopsis:
*     int ChrLen( const char *string, int *status )

*  Class Membership:
*     Plot

*  Description:
*     This function returns the length of a string excluding any trailing
*     white space.

*  Parameters:
*     string
*        Pointer to the string.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The length of a string excluding any trailing white space.

*  Notes:
*     -  A value of zero is returned if a NULL pointer is supplied, or if an
*     error has already occurred.

*/

/* Local Variables: */
   const char *c;      /* Pointer to the next character to check */
   int ret;            /* The returned string length */

/* Check the global status. */
   if( !astOK ) return 0;

/* Initialise the returned string length. */
   ret = 0;

/* Check a string has been supplied. */
   if( string ){

/* Check each character in turn, starting with the last one. */
      ret = strlen( string );
      c = string + ret - 1;
      while( ret ){
         if( !isspace( (int) *c ) ) break;
         c--;
         ret--;
      }
   }

/* Return the answer. */
   return ret;

}

static AstPlotCurveData **CleanCdata( AstPlotCurveData **cdata, int *status ){
/*
*  Name:
*     CleanCdata

*  Purpose:
*     Release the structures holding curve break information.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     AstPlotCurveData **CleanCdata( AstPlotCurveData **cdata, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function releases the memory used to hold the curve break
*     information returned by function DrawGrid, and returns a NULL pointer.

*  Parameters:
*     cdata
*        Pointer to the information to be freed.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A NULL pointer.

*  Notes:
*     -  This function attempts to execute even if an error has already
*     occurred.

*/

/* Return if a NULL pointer has been supplied. */
   if( !cdata ) return NULL;

/* Release each of the two structures in turn (if they exist). */
   (void) astFree( (void *) cdata[ 0 ] );
   (void) astFree( (void *) cdata[ 1 ] );

/* Release the memory used to hold the two AstPlotCurveData pointers. */
   (void) astFree( (void *) cdata );

/* Return. */
   return NULL;

}

static TickInfo **CleanGrid( TickInfo **grid, int *status ){
/*
*  Name:
*     CleanGrid

*  Purpose:
*     Release the structures holding grid information.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     TickInfo **CleanGrid( TickInfo **grid )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function releases the memory used to hold the grid information
*     returned by function GridLines, and returns a NULL pointer.

*  Parameters:
*     grid
*        Pointer to the information to be freed.

*  Returned Value:
*     A NULL pointer.

*  Notes:
*     -  This function attempts to execute even if an error has already
*     occurred.

*/

/* Local Variables: */
   TickInfo *info;             /* Pointer to TickInfo structure being freed */
   int i;                      /* Axis index */
   int j;                      /* Tick mark index */

/* Return if a NULL pointer has been supplied. */
   if( !grid ) return NULL;

/* Release each of the TickInfo structures in turn (if they exist). */
   for( i = 0; i < 2; i++ ){
      if( ( info = grid[ i ] ) ){

/* Release the memory holding major tick mark values. */
         (void) astFree( (void *) info->ticks );

/* Release the memory holding minor tick mark values. */
         (void) astFree( (void *) info->minticks );

/* Release the memory holding curve section starting positions. */
         (void) astFree( (void *) info->start );

/* Release the memory holding curve section lengths. */
         (void) astFree( (void *) info->length );

/* If there are any tick mark labels in the structure... */
         if( info->labels ){

/* Release the memory holding each tick mark label. */
            for( j = 0; j < info->nmajor; j++ ){
               (void) astFree( (void *) info->labels[ j ] );
            }

/* Release the memory holding the pointers to the tick mark labels. */
            (void) astFree( (void *) info->labels );

/* Release the memory holding the format specification string. */
            (void) astFree( (void *) info->fmt );

         }

/* Release the TickInfo structure. */
         (void) astFree( (void *) info );
      }
   }

/* Release the memory used to hold the two TickInfo pointers. */
   (void) astFree( (void *) grid );

/* Return. */
   return NULL;

}

static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     ClearAttrib

*  Purpose:
*     Clear an attribute value for a Plot.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void ClearAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Plot member function (over-rides the astClearAttrib protected
*     method inherited from the FrameSet class).

*  Description:
*     This function clears the value of a specified attribute for a
*     Plot, so that the default value will subsequently be used.

*  Parameters:
*     this
*        Pointer to the Plot.
*     attrib
*        Pointer to a null terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstPlot *this;                /* Pointer to the Plot structure */
   char label[21];               /* Graphics item label */
   const char *class;            /* Pointer to class string */
   int axis;                     /* Axis number */
   int id1;                      /* Plot object id */
   int id2;                      /* Plot object id */
   int id;                       /* Plot object id */
   int len;                      /* Length of attrib string */
   int nax;                      /* Number of base Frame axes */
   int nc;                       /* No. characters read by astSscanf */
   int id3;                      /* Third genuine identifier */
   int nid;                      /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) this_object;

/* Get the number of base Frame axis (2 for a Plot, 3 for a Plot3D). */
   nax = astGetNin( this );

/* Obtain the length of the "attrib" string. */
   len = strlen( attrib );

/* Check the attribute name and clear the appropriate attribute. */

/* Edge(axis). */
/* ------------ */
   if ( nc = 0,
               ( 1 == astSscanf( attrib, "edge(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearEdge( this, axis - 1 );

/* Grid. */
/* ----- */
   } else if ( !strcmp( attrib, "grid" ) ) {
      astClearGrid( this );

/* LabelUp */
/* ------- */
   } else if ( !strcmp( attrib, "labelup" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearLabelUp( this, axis );

/* LabelUp(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelup(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLabelUp( this, axis - 1 );

/* LogPlot */
/* ------- */
   } else if ( !strcmp( attrib, "logplot" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearLogPlot( this, axis );

/* LogPlot(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "logplot(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLogPlot( this, axis - 1 );

/* LogTicks */
/* ------- */
   } else if ( !strcmp( attrib, "logticks" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearLogTicks( this, axis );

/* LogTicks(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "logticks(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLogTicks( this, axis - 1 );

/* LogLabel */
/* ------- */
   } else if ( !strcmp( attrib, "loglabel" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearLogLabel( this, axis );

/* LogLabel(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "loglabel(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLogLabel( this, axis - 1 );

/* NumLab. */
/* ---------- */
   } else if ( !strcmp( attrib, "numlab" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearNumLab( this, axis );

/* NumLab(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "numlab(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearNumLab( this, axis - 1 );

/* MinTick. */
/* ---------- */
   } else if ( !strcmp( attrib, "mintick" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearMinTick( this, axis );

/* MinTick(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "mintick(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearMinTick( this, axis - 1 );

/* TextLab. */
/* ---------- */
   } else if ( !strcmp( attrib, "textlab" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearTextLab( this, axis );

/* TextLab(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "textlab(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearTextLab( this, axis - 1 );

/* LabelUnits. */
/* --------- */
   } else if ( !strcmp( attrib, "labelunits" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearLabelUnits( this, axis );

/* LabelUnits(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelunits(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLabelUnits( this, axis - 1 );

/* Style. */
/* ------ */
   } else if ( !strcmp( attrib, "style" ) ) {
      for( id = 0; id < AST__NPID; id++ ) astClearStyle( this, id );

/* Style(label). */
/* --------------*/
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "style(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, attrib, "astClear", class, status ),
                    nax, &id1, &id2, &id3, status );
      astClearStyle( this, id1 );
      if( nid > 1 ) astClearStyle( this, id2 );
      if( nid > 2 ) astClearStyle( this, id3 );

/* Font. */
/* ----- */
   } else if ( !strcmp( attrib, "font" ) ) {
      for( id = 0; id < AST__NPID; id++ ) astClearFont( this, id );

/* Font(label). */
/* -------------*/
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "font(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, attrib, "astClear", class, status ),
                    nax, &id1, &id2, &id3, status );
      astClearFont( this, id1 );
      if( nid > 1 ) astClearFont( this, id2 );
      if( nid > 2 ) astClearFont( this, id3 );

/* Colour. */
/* ------- */
   } else if ( !strcmp( attrib, "colour" ) ) {
      for( id = 0; id < AST__NPID; id++ ) astClearColour( this, id );

/* Colour(label). */
/* ---------------*/
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "colour(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, attrib, "astClear", class, status ),
                    nax, &id1, &id2, &id3, status );
      astClearColour( this, id1 );
      if( nid > 1 ) astClearColour( this, id2 );
      if( nid > 2 ) astClearColour( this, id3 );

/* Color. */
/* ------ */
   } else if ( !strcmp( attrib, "color" ) ) {
      for( id = 0; id < AST__NPID; id++ ) astClearColour( this, id );

/* Color(label). */
/* --------------*/
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "color(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, attrib, "astClear", class, status ),
                    nax, &id1, &id2, &id3, status );
      astClearColour( this, id1 );
      if( nid > 1 ) astClearColour( this, id2 );
      if( nid > 2 ) astClearColour( this, id3 );

/* Width. */
/* ------ */
   } else if ( !strcmp( attrib, "width" ) ) {
      for( id = 0; id < AST__NPID; id++ ) astClearWidth( this, id );

/* Width(label). */
/* --------------*/
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "width(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, attrib, "astClear", class, status ),
                    nax, &id1, &id2, &id3, status );

      astClearWidth( this, id1 );
      if( nid > 1 ) astClearWidth( this, id2 );
      if( nid > 2 ) astClearWidth( this, id3 );

/* Size. */
/* ----- */
   } else if ( !strcmp( attrib, "size" ) ) {
      for( id = 0; id < AST__NPID; id++ ) astClearSize( this, id );

/* Size(label). */
/* -------------*/
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "size(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, attrib, "astClear", class, status ),
                    nax, &id1, &id2, &id3, status );
      astClearSize( this, id1 );
      if( nid > 1 ) astClearSize( this, id2 );
      if( nid > 2 ) astClearSize( this, id3 );

/* LabelAt(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelat(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLabelAt( this, axis - 1 );

/* Centre(axis). */
/* ------------ */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "centre(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearCentre( this, axis - 1 );

/* Gap. */
/* ---- */
   } else if ( !strcmp( attrib, "gap" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearGap( this, axis );

/* Gap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "gap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearGap( this, axis - 1 );

/* LogGap. */
/* ----------- */
   } else if ( !strcmp( attrib, "loggap" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearLogGap( this, axis );

/* LogGap(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "loggap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearLogGap( this, axis - 1 );

/* NumLabGap. */
/* ---------- */
   } else if ( !strcmp( attrib, "numlabgap" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearNumLabGap( this, axis );

/* NumLabGap(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "numlabgap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearNumLabGap( this, axis - 1 );

/* TextLabGap. */
/* ----------- */
   } else if ( !strcmp( attrib, "textlabgap" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearTextLabGap( this, axis );

/* TextLabGap(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "textlabgap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearTextLabGap( this, axis - 1 );

/* TitleGap. */
/* --------- */
   } else if ( !strcmp( attrib, "titlegap" ) ) {
      astClearTitleGap( this );

/* MajTickLen. */
/* ----------- */
   } else if ( !strcmp( attrib, "majticklen" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearMajTickLen( this, axis );

/* MajTickLen(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "majticklen(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearMajTickLen( this, axis - 1 );

/* MinTickLen. */
/* ----------- */
   } else if ( !strcmp( attrib, "minticklen" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearMinTickLen( this, axis );

/* MinTickLen(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "minticklen(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearMinTickLen( this, axis - 1 );

/* Labelling. */
/* -------- */
   } else if ( !strcmp( attrib, "labelling" ) ) {
      astClearLabelling( this );

/* TextGapType. */
/* ------------ */
   } else if ( !strcmp( attrib, "textgaptype" ) ) {
      astClearTextGapType( this );

/* TickAll. */
/* -------- */
   } else if ( !strcmp( attrib, "tickall" ) ) {
      astClearTickAll( this );

/* ForceExterior */
/* ------------- */
   } else if ( !strcmp( attrib, "forceexterior" ) ) {
      astClearForceExterior( this );

/* Invisible. */
/* ---------- */
   } else if ( !strcmp( attrib, "invisible" ) ) {
      astClearInvisible( this );

/* Border. */
/* ------- */
   } else if ( !strcmp( attrib, "border" ) ) {
      astClearBorder( this );

/* ClipOp. */
/* ------- */
   } else if ( !strcmp( attrib, "clipop" ) ) {
      astClearClipOp( this );

/* Clip. */
/* ----- */
   } else if ( !strcmp( attrib, "clip" ) ) {
      astClearClip( this );

/* Grf. */
/* ---- */
   } else if ( !strcmp( attrib, "grf" ) ) {
      astClearGrf( this );

/* DrawTitle. */
/* ---------- */
   } else if ( !strcmp( attrib, "drawtitle" ) ) {
      astClearDrawTitle( this );

/* DrawAxes. */
/* --------- */
   } else if ( !strcmp( attrib, "drawaxes" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearDrawAxes( this, axis );

/* Abbrev */
/* ------ */
   } else if ( !strcmp( attrib, "abbrev" ) ) {
      for( axis = 0; axis < nax; axis++ ) astClearAbbrev( this, axis );

/* DrawAxes(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "drawaxes(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearDrawAxes( this, axis - 1 );

/* Abbrev(axis). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "abbrev(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      astClearAbbrev( this, axis - 1 );

/* Escape. */
/* ------- */
   } else if ( !strcmp( attrib, "escape" ) ) {
      astClearEscape( this );

/* Tol. */
/* ---- */
   } else if ( !strcmp( attrib, "tol" ) ) {
      astClearTol( this );

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_clearattrib)( this_object, attrib, status );
   }
}

static void ClearLogPlot( AstPlot *this, int axis, int *status ){
/*
*
*  Name:
*     ClearLogPlot

*  Purpose:
*     Clear the value for a LogPlot attribute

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void ClearLogPlot( AstPlot *this, int axis, int *status )

*  Class Membership:
*     Plot member function

*  Description:
*     Assigns the default value to the LogPlot attribute of the specified
*     axis, and also re-maps the base Frame of the Plot if necessary.

*  Parameters:
*     this
*        The Plot.
*     axis
*        Zero based axis index.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int oldval;           /* Original value of the attribute */
   int newval;           /* Cleared (default) value of the attribute */

/* Check the global error status. */
   if ( !astOK ) return;

/* Validate the axis index. */
   if( axis < 0 || axis >= 2 ){
      astError( AST__AXIIN, "astClearLogPlot(%s): Index (%d) is invalid for "
                "attribute LogPlot - it should be in the range 1 to 2.", status,
                astGetClass( this ), axis + 1 );

/* Do nothing if the attribute is not currently set. */
   } else if( astTestLogPlot( this, axis ) ){

/* Get the original value of the attribute. clear the value, and then get
   the new (default) value. */
      oldval = this->logplot[ axis ];
      this->logplot[ axis ] = -1;
      newval = astGetLogPlot( this, axis );

/* If the effective value has changed, attempt to remap the axis. If this
   fails, re-instate the original value. */
      if( ( oldval != 0 ) != ( newval != 0 ) ) {
         if( !ToggleLogLin( this, axis, oldval, "astClearLogPlot", status ) ) {
            this->logplot[ axis ] = oldval;
         }
      }
   }
}

static void Clip( AstPlot *this, int iframe, const double lbnd[],
                  const double ubnd[], int *status ){
/*
*++
*  Name:
c     astClip
f     AST_CLIP

*  Purpose:
*     Set up or remove clipping for a Plot.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astClip( AstPlot *this, int iframe, const double lbnd[],
c                   const double ubnd[] )
f     CALL AST_CLIP( THIS, IFRAME, LBND, UBND, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function defines regions of a Plot which are to be clipped.
f     This routine defines regions of a Plot which are to be clipped.
*     Any subsequent graphical output created using the Plot will then
*     be visible only within the unclipped regions of the plotting
*     area. See also the Clip attribute.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     iframe
f     IFRAME = INTEGER (Given)
*        The index of the Frame within the Plot to which the clipping
c        limits supplied in "lbnd" and "ubnd" (below) refer. Clipping
f        limits supplied in LBND and UBND (below) refer. Clipping
*        may be applied to any of the coordinate systems associated
*        with a Plot (as defined by the Frames it contains), so this
*        index may take any value from 1 to the number of Frames in
*        the Plot (Nframe attribute). In addition, the values
*        AST__BASE and AST__CURRENT may be used to specify the base
*        and current Frames respectively.
*
*        For example, a value of AST__CURRENT causes clipping to be
*        performed in physical coordinates, while a value of AST__BASE
*        would clip in graphical coordinates. Clipping may also be
*        removed completely by giving a value of AST__NOFRAME. In this
*        case any clipping bounds supplied (below) are ignored.
c     lbnd
f     LBND( * ) = DOUBLE PRECISION (Given)
*        An array with one element for each axis of the clipping Frame
c        (identified by the index "iframe"). This should contain the
f        (identified by the index IFRAME). This should contain the
*        lower bound, on each axis, of the region which is to remain
*        visible (unclipped).
c     ubnd
f     UBND( * ) = DOUBLE PRECISION (Given)
*        An array with one element for each axis of the clipping Frame
c        (identified by the index "iframe"). This should contain the
f        (identified by the index IFRAME). This should contain the
*        upper bound, on each axis, of the region which is to remain
*        visible (unclipped).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
c     - Only one clipping Frame may be active at a time. This function
f     - Only one clipping Frame may be active at a time. This routine
*     will deactivate any previously-established clipping Frame before
*     setting up new clipping limits.
c     - The clipping produced by this function is in addition to that
f     - The clipping produced by this routine is in addition to that
*     specified by the Clip attribute which occurs at the edges of the
*     plotting area
c     established when the Plot is created (see astPlot). The
f     established when the Plot is created (see AST_PLOT). The
*     underlying graphics system may also impose further clipping.
*     - When testing a graphical position for clipping, it is first
*     transformed into the clipping Frame. The resulting coordinate on
*     each axis is then checked against the clipping limits (given by
c     "lbnd" and "ubnd"). By default, a position is clipped if any
f     LBND and UBND). By default, a position is clipped if any
*     coordinate lies outside these limits. However, if a non-zero
*     value is assigned to the Plot's ClipOp attribute, then a
*     position is only clipped if the coordinates on all axes lie
*     outside their clipping limits.
*     - If the lower clipping limit exceeds the upper limit for any
*     axis, then the sense of clipping for that axis is reversed (so
*     that coordinate values lying between the limits are clipped
*     instead of those lying outside the limits). To produce a "hole"
*     in a coordinate space (that is, an internal region where nothing
*     is plotted), you should supply all the bounds in reversed order,
*     and set the ClipOp attribute for the Plot to a non-zero value.
*     - Either clipping limit may be set to the value AST__BAD, which
*     is equivalent to setting it to infinity (or minus infinity for a
*     lower bound) so that it is not used.
*     - If a graphical position results in any bad coordinate values
*     (AST__BAD) when transformed into the clipping Frame, then it is
*     treated (for the purposes of producing graphical output) as if
*     it were clipped.
*     - When a Plot is used as a Mapping to transform points
c     (e.g. using astTran2), any clipped output points are assigned
f     (e.g. using AST_TRAN2), any clipped output points are assigned
*     coordinate values of AST__BAD.
*     - An error results if the base Frame of the Plot is not
*     2-dimensional.
*--
*/

/* Local Variables: */
   AstFrame *fr;           /* Pointer to the clipping Frame */
   AstFrameSet *fset;      /* Pointer to the Plot's FrameSet */
   int i;                  /* Axis index */
   int ifrm;               /* The validated frame index */
   int naxes;              /* No. of axes in the base Frame */

/* Check the global error status. */
   if ( !astOK ) return;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   ifrm = 0;

/* Get a pointer to the FrameSet at the start of the Plot. */
   fset = (AstFrameSet *) this;

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( fset );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "astClip(%s): Number of axes (%d) in the "
                "base Frame of the supplied %s is invalid - this number "
                "should be 2.", status, astGetClass( this ), naxes,
                astGetClass( this ) );
   }

/* If clipping is to be switched on, check the supplied frame index and
   bounds. */
   if( iframe != AST__NOFRAME && astOK ) {

/* Report an error if either of the bounds pointers is NULL.*/
      if( !lbnd ){
         astError( AST__CLPAX, "astClip(%s): A NULL pointer was "
                   "supplied for the array holding the lower bounds of "
                   "the clipping volume.", status, astGetClass( this ) );
      } else if( !ubnd ){
         astError( AST__CLPAX, "astClip(%s): A NULL pointer was "
                   "supplied for the array holding the upper bounds of "
                   "the clipping volume.", status, astGetClass( this ) );
      }

/* Validate the clipping frame index. */
      ifrm = astValidateFrameIndex( fset, iframe, "astClip" );

/* Get the number of axes in the clipping frame. */
      fr = astGetFrame( this, ifrm );
      naxes = astGetNaxes( fr );
      fr = astAnnul( fr );

   }

/* Leave the current clipping information unchanged if an error has
   occurred. */
   if( astOK ){

/* Remove all clipping information from the Plot. */
      this->clip_lbnd = (double *) astFree( (void *) this->clip_lbnd );
      this->clip_ubnd = (double *) astFree( (void *) this->clip_ubnd );
      this->clip_frame = AST__NOFRAME;
      this->clip_axes = 0;

/* If bounds have been supplied, set up new clipping information. */
      if( iframe != AST__NOFRAME ){

/* Store the information. */
         this->clip_frame = ifrm;
         this->clip_lbnd = astStore( NULL, lbnd, sizeof(double)*(size_t)naxes );
         this->clip_ubnd = astStore( NULL, ubnd, sizeof(double)*(size_t)naxes );
         this->clip_axes = naxes;

/* If an error has occurred, remove all clipping information. */
         if( !astOK ){
            this->clip_lbnd = (double *) astFree( (void *) this->clip_lbnd );
            this->clip_ubnd = (double *) astFree( (void *) this->clip_ubnd );
            this->clip_frame = AST__NOFRAME;
            this->clip_axes = 0;

/* Otherwise, replace any bounds of AST__BAD with suitable default
   values. */
         } else {
           for( i = 0; i < naxes; i++ ){
              if( this->clip_lbnd[ i ] == AST__BAD ) this->clip_lbnd[ i ] = -DBL_MAX;
              if( this->clip_ubnd[ i ] == AST__BAD ) this->clip_ubnd[ i ] = DBL_MAX;
           }

         }

      }

   }

/* Return. */
   return;

}

static int Compared( const void *elem1, const void *elem2 ){
/*
*  Name:
*     Compared

*  Purpose:
*     Compare two "double" values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Compared( const void *elem1, const void *elem2 )

*  Class Membership:
*     Plot method.

*  Description:
*     This function compares the two "double" values to which pointers
*     are supplied, and returns an integer indicating which is larger,
*     checking for AST__BAD values.  It is intended for use with the C
*     Run-Time-Library sorting function "qsort".

*  Parameters:
*     elem1
*        Pointer to the first "double".
*     elem2
*        Pointer to the second "double".

*  Returned Value:
*     Zero is returned if the values are equal. If the first is larger
*     than the second then +1 is returned. Otherwise, -1 is returned.

*  Notes:
*     -  Values of AST__BAD are considered to be larger than any other
*     value (other than another value of AST__BAD).
*     -  If both values are AST__BAD, then zero is returned.
*     -  This function executes even if an error has occurred.

*/

/* Local Variables: */
   double *delem1;    /* Pointer to the first "double" value */
   double *delem2;    /* Pointer to the second "double" value */
   int ret;           /* The returned value */

/* Get pointers to the two "double" values. */
   delem1 = (double *) elem1;
   delem2 = (double *) elem2;

/* Check the values for equality (including both values being AST__BAD). */
   if( *delem1 == *delem2 ){
      ret = 0;

/* If the first is bad, then it is considered to be larger than the
   second. */
   } else if( *delem1 == AST__BAD ){
      ret = 1;

/* If the second is bad, then it is considered to be larger than the
   first. */
   } else if( *delem2 == AST__BAD ){
      ret = -1;

/* If the first is larger than the second, return 1. */
   } else if( *delem1 > *delem2 ){
      ret = 1;

/* If the first is smaller than the second, return -1. */
   } else {
      ret = -1;

   }

/* Return the answer. */
   return ret;

}

static int Compare_LL( const void *elem1, const void *elem2 ){
/*
*  Name:
*     Compare_LL

*  Purpose:
*     Compare two LabelList structures as used by function PlotLabels.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Compare_LL( const void *elem1, const void *elem2 )

*  Class Membership:
*     Plot method.

*  Description:
*     This function compares two "LabelList" structures as used by function
*     PlotLabels, and returns an integer indicating which has a larger
*     "index" value. This function is intended to be used with the C
*     Run-Time-Library sorting function "qsort".

*  Parameters:
*     elem1
*        Pointer to the first LabelList.
*     elem2
*        Pointer to the second LabelList.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Zero is returned if the values are equal. If the first is larger
*     than the second then +1 is returned. Otherwise, -1 is returned.

*  Notes:
*     -  This function executes even if an error has occurred.

*/

/* Local Variables: */
   LabelList *ll1;           /* Pointer to the first LabelList */
   LabelList *ll2;           /* Pointer to the second LabelList */
   int ret;                  /* The returned value */

/* Get pointers to the two LabelList structures. */
   ll1 = (LabelList *) elem1;
   ll2 = (LabelList *) elem2;

/* Compare the indices for the two label's. */
   if( ll1->index < ll2->index ){
      ret = -1;

   } else if( ll1->index > ll2->index ){
      ret = 1;

   } else {
      ret = 0;
   }

/* Return the answer. */
   return ret;

}

static void CopyPlotDefaults( AstPlot *this, int axis, AstPlot *dplot,
                             int daxis, int *status ){
/*
*+
*  Name:
*     astCopyPlotDefaults

*  Purpose:
*     Copy used attribute defaults from one Plot to another.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot.h"
*     void astCopyPlotDefaults( AstPlot *this, int axis, AstPlot *dplot,
*                               int daxis )

*  Class Membership:
*     Plot method.

*  Description:
*     Some of the attributes used by the Plot class have dynamic default
*     values that are determined during the process of drawing an annotated
*     grid using astGrid. The dynamic default values are stored in a
*     separate set of components within the Plot structure. This function
*     copies these components from one Plot to another.

*  Parameters:
*     this
*        Pointer to a Plot containing the values to be copied.
*     axis
*        The zero-based index of the axis within "this" for which the
*        used defaults are to be copied.
*     dplot
*        A pointer to another Plot into which the default attribute
*        values are to be copied.
*     daxis
*        The zero based index of the axis within "dplot" which is to
*        receive the new values.

*-
*/

/* Check the global status. */
   if( !astOK ) return;

   dplot->ulglb[ daxis ] = this->ulglb[ axis ];
   dplot->ulgtk[ daxis ] = this->ulgtk[ axis ];
   dplot->uloggap[ daxis ] = this->uloggap[ axis ];
   dplot->ugap[ daxis ] = this->ugap[ axis ];
   dplot->ucentre[ daxis ] = this->ucentre[ axis ];
   dplot->uedge[ daxis ] = this->uedge[ axis ];
   dplot->ulblat[ daxis ] = this->ulblat[ axis ];
   dplot->ulbunit[ daxis ] = this->ulbunit[ axis ];
   dplot->umintk[ daxis ] = this->umintk[ axis ];
   dplot->utxtlb[ daxis ] = this->utxtlb[ axis ];
   dplot->umjtkln[ daxis ] = this->umjtkln[ axis ];

   dplot->ugrid = this->ugrid;
   dplot->ulbling = this->ulbling;
   dplot->uborder = this->uborder;
}

static int CountGood( int n, double *data, int *status ){
/*
*  Name:
*     CountGood

*  Purpose:
*     Coount the number of non-bad values in an array.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int CountGood( int n, double *data, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function returns the number of elements in the supplied array
*     which do not have the value AST__BAD.

*  Parameters:
*     n
*        The total number of elements in the array.
*     data
*        Pointer to the start of the array.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The number of good points in the array.

*  Notes:
*     -  A value of zero is returned if an error has already occurred.

*/

/* Local Variables: */
   int i;
   int ngood;
   double *value;

/* Check global status. */
   if( !astOK ) return 0;

/* Initialise a pointer to the next array element, and the number of
   good elements found so far. */
   value = data;
   ngood = 0;

/* Check each element. */
   for( i = 0; i < n; i++ ){
      if( *(value++) != AST__BAD ) ngood++;
   }

/* Return the answer. */
   return ngood;

}

static int Cross( float ax, float ay, float bx, float by,
                  float cx, float cy, float dx, float dy, int *status ){
/*
*  Name:
*     Cross

*  Purpose:
*     See if two line segments intersect.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Cross( float ax, float ay, float bx, float by,
*                float cx, float cy, float dx, float dy, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function sees if the line segment (A,B) intersects the line
*     segment (C,D).

*  Parameters:
*     ax, ay
*        The coordinates of A.
*     bx, by
*        The coordinates of B.
*     cx, cy
*        The coordinates of C.
*     dx, dy
*        The coordinates of D.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Zero if the line segments do not cross or if an error has already
*     occurred, and 1 if they do.

*/

/* Local Variables: */
   int ret;
   float m1, m2, denom, num, t1, t2;

/* Check the inherited status. */
   if( !astOK ) return 0;

/* Get the fraction of the distance from A to B at which the line AB
   intersects the line CD. */
   m1 = dx - cx;
   m2 = dy - cy;
   denom = (bx - ax)*m2 - (by-ay)*m1;
   num = (ay - cy)*m1 - (ax - cx)*m2;

   if( denom != 0.0 ) {
      t1 = num / denom;

/* If the the intersection occurs within the segment of the line between A
   and B... */
      if( t1 >= 0.0 && t1 <= 1.0 ){

/* ... then get the fraction of the distance from C to D at which the
   line CD intersects the line AB. */
         m1 = bx - ax;
         m2 = by - ay;
         denom = (dx - cx)*m2 - (dy-cy)*m1;
         num = (cy - ay)*m1 - (cx - ax)*m2;

         if( denom != 0.0 ) {
            t2 = num / denom;

/* If the the intersection occurs within the segment of the line between C
   and D then the line segments intersect. */
            if( t2 >= 0.0 && t2 <= 1.0 ){
               ret = 1;
            } else {
               ret = 0;
            }

/* If the two lines are parallel, then they do not intersect. */
         } else {
            ret = 0;
         }

      } else {
         ret = 0;
      }

   } else {
      ret = 0;

   }

   return ret;
}

static void Crv( AstPlot *this, double *d, double *x, double *y, int skipbad,
                 double *box, CrvStatics *pstatics, const char *method,
                 const char *class, int *status ){
/*
*  Name:
*     Crv

*  Purpose:
*     Draw a curve.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Crv( AstPlot *this, double *d, double *x, double *y, int skipbad,
*               double *box, CrvStatics *pstatics, const char *method,
*               const char *class, int *status  )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws a curve parameterised by the distance from some
*     starting point. The function pointed to by the external variable
*     Crv_map is used to transform distances along the curve into graphics
*     coordinates (X,Y). The supplied function parameters defined the
*     section of the curve to be drawn.
*
*     The algorithm used needs no knowledge about the nature of the mapping
*     performed by Crv_map, and can handle discontinuities in the curve. It
*     first of all determines if any of the segments of the curve can be
*     adequately represented by simply drawing a straight line through the
*     supplied end points. This decision is based on several requirements such
*     as keeping the angle between adjacent sections low and both ends being
*     defined (i.e. X and Y not equal to AST__BAD). Any segments of the curve
*     which satisfy the requirements are draw as straight lines. If any of
*     the supplied curve segments cannot be drawn in this way, then they are
*     split up into a set of evenly-spaced sub-segments and the graphics
*     coordinates at the ends of these sub-segments are found using Crv_map.
*     This function is then called recursively to draw the sub-segments. This
*     recursion is limited in depth by the requirement that all the
*     sub-segments must be longer than a specified lower limit. If this is not
*     the case, then the curve is assumed to be dis-continuous and and the
*     sub-segments are ignored.

*  Parameters:
*     d
*        Pointer to an array of CRV_NPNT values giving the distance along
*        the curve from the starting point to each of CRV_NPNT points. They
*        should increase monotonically, and should be in whatever units are
*        used by the function pointed to by Crv_map. The curve is drawn from
*        d[0] to d[CRV_NPNT].
*     x
*        Pointer to an array of CRV_NPNT values giving the graphics X
*        coordinate for the positions supplied in the array pointed to by
*        parameter "d".
*     y
*        Pointer to an array of CRV_NPNT values giving the graphics Y
*        coordinate for the positions supplied in the array pointed to by
*        parameter "d".
*     skipbad
*        Controls what happens if all the supplied points are bad or
*        outside the plotting area. If skipbad is non-zero, then it is
*        assumed that the supplied points represent an entirely bad (or
*        out of bounds) section of the curve, and this function will
*        return without attempt to sub-divide any of the supplied points.
*        If skipbad is zero, then it is assumed that we may be able to find
*        some good points between the supplied bad points, and therefore
*        this function will attempt to sub-divide the supplied points.
*        Should be supplied as zero on the initial invocation.
*     box
*        Pointer to an array of 4 doubles houlding a bounding box within
*        which the current segment must reside if it is to be sub-divided.
*        Supplied in the order xlo, xhi, ylo, yhi. May be NULL in which
*        case, no check is made on the bounding box.
*     pstatics
*        Pointer to a structure holding values for variables which were
*        statically defined within this function prior to the thread-safe
*        version of AST. If a NULL pointer is supplied, a new structure
*        is created in dynamic memory and initialised.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  External Variables:
*     Crv_nent = int (Read/Write)
*        The number of recursive entries which have been made into
*        this function. This should be set to zero before entering
*        this function for the first time.
*     Crv_ux0 = double (Read/Write)
*        The X component in graphics coordinates of the unit vector
*        along the previous segment of the curve. This should be set
*        to AST__BAD initially to indicate that the previous section
*        is not defined.
*     Crv_uy0 = double (Read/Write)
*        The Y component of the unit vector along the previous segment.
*     Crv_limit = double (Read)
*        The square of the maximum acceptable residual between the
*        drawn curve and the true curve, in graphics coordinates.
*     Crv_scerr = double (Read)
*        If the ratio of the lengths of adjacent sub-segments is larger
*        than Crv_scerr,then the sub-segments will be sub-divided. Note,
*        if either axis is mapped logarithmically onto the screen, then
*        there will naturally be large changes in scale. Crv_scerr should
*        always be larger than 1.0.
*     Crv_map = void (*)( int n, double *dd, double *xx, double *yy,
*                         const char *method, const char *class ) (Read)
*        A pointer to a function which can be called to map "n" distances
*        along the curve (supplied in "dd") into graphics coordinates
*        (stored in "xx" and "yy"). See function "Map1" as an example.
*     Crv_clip = int (Read)
*        Should lines be clipped at the edge of the plotting area?

*  Notes:
*     - The CRV_TRACE conditional compilation blocks in this function
*     provide code which displays the recursive entries made to this
*     function (and also pauses on initial entry until return is pressed).
*     It is useful for investigating the details of the drawing of a
*     curve.

*/

/* Local Variables: */
   astDECLARE_GLOBALS     /* Pointer to thread-specific global data */
   CrvStatics *statics;   /* Pointer to structure holding static values */
   double *dd;            /* Pointer to array holding sub-segment distances */
   double *pd;            /* Pointer to next sub-segment distance */
   double *px;            /* Pointer to next sub-segment x coord. */
   double *py;            /* Pointer to next sub-segment y coord. */
   double *xx;            /* Pointer to array holding sub-segment x coord.s */
   double *yy;            /* Pointer to array holding sub-segment x coord.s */
   double bbox[4];        /* Bounding box for this segment */
   double dl2[ CRV_NSEG ];/* Squred segment lengths */
   double dx[ CRV_NSEG ]; /* X increment along each segment */
   double dy[ CRV_NSEG ]; /* Y increment along each segment */
   double totlen;         /* Total of all segment lengths */
   int i;                 /* Segment index */
   int seg_ok[ CRV_NSEG ];/* Flags indicating which segments can be drawn */
   int subdivide;         /* Flag indicating if segments can be subdivided */

/* Check inherited status */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* If required, allocate memory for a structure to hold the static
   variables need by this function. */
   if( ! pstatics ) {
      statics = astMalloc( sizeof( CrvStatics ) );
   } else {
      statics = pstatics;
   }

/* If this is the first entry, set up the minimum length for a
   sub-segment in graphics coordinates. If any segment is less than
   this minimum length, then recursion will stop and the curve will
   be assumed to be dis-continuous. */
   if( !Crv_nent ) {
      statics->limit2 = 20.0*Crv_limit/(CRV_NSEG*CRV_NSEG);

#ifdef CRV_TRACE
      statics->levels[ 0 ] = 0;
#endif
   }


/* Increment the number of entries into this function. */
   Crv_nent++;

#ifdef CRV_TRACE
   for( i = 0; i < Crv_nent; i++ ) {
      printf("%d ",statics->levels[ i ] );
   }
   printf("\n");

   if( getchar() == 'm' ) {
      float ffx,ffy;
      for( i = 0; i < CRV_NPNT; i++ ) {
         ffx = x[i]; ffy = y[i];
         GMark( this, 1, &ffx, &ffy, 2, method, class, status );
         GFlush( this, method, class, status );
      }
   }
#endif

/* ======================================================================
   The first section of this function sets up some arrays holding
   information which will be used later on. It looks at each of the segments
   joing adjacent tabulated points, and finds and stores the increments in
   X and Y along each segment, and the square of the segment length. It
   also checks to see if the tabulated points are all bad, or if they are
   all good. It also finds the lowest squared segment length.
   ======================================================================*/

/* Look at the first tabulated point. If it is good, set a flag to indicate
   that it can be used, store it as "the previous position" (i.e. the start of
   the current segment). Also set a flag ("all_bad") to indicate if all
   points looked at so far have been bad, or outside the plotting area. */
   if( *x != AST__BAD && *y != AST__BAD ){
      statics->last_ok = 1;
      statics->last_x = *x;
      statics->last_y = *y;
      statics->all_bad = ( *x < Crv_xlo || *x > Crv_xhi ||
                  *y < Crv_ylo || *y > Crv_yhi ) && Crv_clip;
   } else {
      statics->last_ok = 0;
      statics->all_bad = 1;
   }

/* Initialise the bounding box for this segment. */
   bbox[ 0 ] = DBL_MAX;
   bbox[ 1 ] = -DBL_MAX;
   bbox[ 2 ] = DBL_MAX;
   bbox[ 3 ] = -DBL_MAX;

/* Store pointers to the X and Y values for the "current position". This
   is the position at the end of the current segment. This is initially
   the second tabulated point. */
   px = x + 1;
   py = y + 1;

/* Store pointers to the increments and squared length for the current
   segment. */
   statics->pdx = dx;
   statics->pdy = dy;
   statics->pdl2 = dl2;

/* Initialise the number of long and short segments, and the total length
   of all segments. */
   statics->nlong = 0;
   statics->nshort = 0;
   totlen = 0.0;

/* Loop round each segment. */
   for( i = 0; i < CRV_NSEG; i++ ){

/* If the tabulated point marking the end of the segment is good... */
      if( *px != AST__BAD && *py != AST__BAD ){

/* Update the bounding box. */
         if( *px < bbox[ 0 ] ) bbox[ 0 ] = *px;
         if( *px > bbox[ 1 ] ) bbox[ 1 ] = *px;
         if( *py < bbox[ 2 ] ) bbox[ 2 ] = *py;
         if( *py > bbox[ 3 ] ) bbox[ 3 ] = *py;

/* If the point is within the plotting area, set the "statics->all_bad" flag to
   indicate that at least 1 point is within the plotting area. */
         if( !Crv_clip || ( *px >= Crv_xlo && *px <= Crv_xhi &&
                            *py >= Crv_ylo && *py <= Crv_yhi ) ) statics->all_bad = 0;

/* If the point marking the start of the segment was also good, find and
   store the increments and squared length for the segment, incrementing
   the pointers ready for the next segment. */
         if( statics->last_ok ){
            statics->t1 = *px - statics->last_x;
            statics->t2 = *py - statics->last_y;
            statics->t3 = statics->t1*statics->t1 + statics->t2*statics->t2;
            *(statics->pdx++) = statics->t1;
            *(statics->pdy++) = statics->t2;
            *(statics->pdl2++) = statics->t3;

/* Measure the total length of all segments. */
            if( totlen != AST__BAD ) totlen += sqrt( statics->t3 );

/* Count the number of segments which are, and are not, shorter than the
   minimum significant length. */
            if( statics->t3 > statics->limit2 ) {
               statics->nlong++;
            } else {
               statics->nshort++;
            }

/* If the start was bad, the length of the segment is not defined so store
   bad values. */
         } else {
            *(statics->pdx++) = AST__BAD;
            *(statics->pdy++) = AST__BAD;
            *(statics->pdl2++) = AST__BAD;
            totlen = AST__BAD;
         }

/* The point at the end of the current segment becomes the point at the
   start of the next segment. */
         statics->last_ok = 1;
         statics->last_x = *(px++);
         statics->last_y = *(py++);

/* If the tabulated point marking the end of the current segment is bad,
   the segment length is undefined so store bad values. */
      } else {
         *(statics->pdx++) = AST__BAD;
         *(statics->pdy++) = AST__BAD;
         *(statics->pdl2++) = AST__BAD;
         totlen = AST__BAD;

/* The point at the end of the current segment becomes the point at the
   start of the next segment. */
         statics->last_ok = 0;
         px++;
         py++;
      }
   }

/* ======================================================================
   The next section of this function checks to see lines can be drawn
   directly through any of the tabulated points. The flags in  "seg_ok"
   indicates if this is the case for each segment.
   ======================================================================*/

/* The unit vector along the previous segment is supplied in external
   variables Crv_ux0 and Crv_uy0. These will be AST__BAD if the direction
   of the previous segment is undefined. */
   statics->vxl = Crv_ux0;
   statics->vyl = Crv_uy0;

/* The length of the previous segment is initially bad. */
   statics->dll = AST__BAD;

/* Set up some pointers used to walk through the arrays holding the lengths
   of each segment. */
   statics->pdl2 = dl2;
   statics->pdx = dx;
   statics->pdy = dy;

/* Normalise and square totlen so that we can compare it to Crv_limit */
   if( totlen != AST__BAD ) {
      totlen /= CRV_NSEG;
      totlen *= totlen;
   }

/* Check each segment in turn to see if it can b0e drawn as a single
   straight line. */
   for( i = 0; i < CRV_NSEG; i++ ){

/* A segment can only be drawn as a single line if both ends are good
   and the distance between them is not zero. */
      if( *statics->pdl2 != AST__BAD && *statics->pdl2 > 0.0 ){

/* Get a unit vector in the direction of the current segment. */
         statics->dl = sqrt( *statics->pdl2 );
         statics->vx = *statics->pdx/statics->dl;
         statics->vy = *statics->pdy/statics->dl;

/* If all segments are good and the total of all segments is very short,
   draw it as a single line. */
         if( totlen != AST__BAD && totlen < Crv_limit ) {
            seg_ok[ i ] = 1;

/* Otherwise, if a unit vector in the direction of the previous segment is
   available, we check that the angle between the previous segment and the current
   segment is not too high. */
         } else if( statics->vxl != AST__BAD ){
            statics->cosang = statics->vxl*statics->vx + statics->vyl*statics->vy;

/* If the angle is too high, set a flag to indicate that the segment cannot
   be drawn as a single line. Also, set the flag for the previous segment as
   well. */
            if( statics->cosang < 0.8 ||
                ( *statics->pdl2 )*( 1.0 - statics->cosang*statics->cosang ) > Crv_limit ) {
               seg_ok[ i ] = 0;
               if( i > 0 ) seg_ok[ i - 1 ] = 0;


/* If the angle between this segment and the previous segment is not too
   high, check that the scale has not changed too much. */
            } else {

/* If the scale (=vector length) has changed a lot, set a flag to indicate
   that the segment cannot be drawn as a single line. Also, set the flag for
   the previous segment as well. */
               if( statics->dll != AST__BAD && ( statics->dl < statics->dll/Crv_scerr || statics->dl > statics->dll*Crv_scerr ) ) {
                  seg_ok[ i ] = 0;
                  if( i > 0 ) seg_ok[ i - 1 ] = 0;

/* If the orientation and scale of this segment has not changed much from
   the previous segment, the segment can be drawn as a straight line. */
               } else {
                  seg_ok[ i ] = 1;
               }
            }

/* If no unit vector is available for the previous segment, then assume
   we are re-starting the curve after a discontinuity. In this case, we
   can draw it as a straight line. */
         } else {
            seg_ok[ i ] = 1;
         }

/* Save the unit vector along the current segment for use next time. */
         statics->vxl = statics->vx;
         statics->vyl = statics->vy;

/* Save the length if the current segment for use next time. */
         statics->dll = statics->dl;

/* If the length of the current segment is undefined, or zero, we cannot
   draw it as a single line. Also, there is no direction vector to pass
   on to the next time, so set them bad. */
      } else {
         seg_ok[ i ] = 0;
         statics->vxl = AST__BAD;
         statics->vyl = AST__BAD;
         statics->dll = AST__BAD;
      }

/* Point to the next segment. */
      statics->pdl2++;
      statics->pdx++;
      statics->pdy++;

   }

/* Do not allow isolated segments to be OK. If a segment is flagged as being
   OK, but both its neighbours are not OK, set the segment not OK as well. */
   statics->seg0 = seg_ok + 1;
   statics->segm = seg_ok;
   statics->segp = seg_ok + 2;

   if( !(*statics->seg0) ) *statics->segm = 0;

   for( i = 1; i < CRV_NSEG - 1; i++ ){
      if( !(*statics->segm) && !(*statics->segp) ) *statics->seg0 = 0;
      statics->seg0++;
      statics->segm++;
      statics->segp++;
   }

   if( !(*statics->segm) ) *statics->seg0 = 0;

/* ======================================================================
   The next section of this function draws the curve. Each segment is drawn
   as a straight line if the corresponding flag in "seg_ok" is set.
   Segments for which the flag is not set are drawn by calling this function
   recursivly.
   ======================================================================*/

/* Get the parametric length (i.e. the increment in "d") of the sub-segments
   within each subdivided segment. */
   statics->delta = ( d[ CRV_NSEG ] - d[ 0 ] )/(double)( CRV_NSEG*CRV_NSEG );

/* If we have made the maximum number of recursive entries into this
   function, or if every supplied point was bad or outside the plotting
   area, or if most of the segments were very short in graphics space, we will
   not be attempting to subdivide any segments which cannot be drawn directly
   as a straight line. If "skipbad" was supplied as zero, we ignore the
   restriction which says that we must have some good points (since we
   may find some good poits by a further sub-division). */
   subdivide = ( Crv_nent < CRV_MXENT &&
                 ( !statics->all_bad || !skipbad ) &&
                 statics->nlong > statics->nshort );

/* We do not sub-divide if the bounding box of the supplied points
   is not at least 10% smaller than the supplied bouding box on either axis. */
   if( box && bbox[ 0 ] != DBL_MAX ) {
      if( bbox[ 1 ] - bbox[ 0 ] > 0.9*( box[ 1 ] - box[ 0 ] ) &&
          bbox[ 3 ] - bbox[ 2 ] > 0.9*( box[ 3 ] - box[ 2 ] ) ) {
         subdivide = 0;
      }
   }

/* Initialise some pointers to the data defineding the subsegments. */
   dd = NULL;
   xx = NULL;
   yy = NULL;

/* If we may be subdividing any segments, find which segments they are
   and set up the offset to each sub-segment. */
   if( subdivide ){

/* Initialise the number of segments being subdivided. */
      statics->nseg = 0;

/* Loop round each segment. */
      for( i = 0; i < CRV_NSEG; i++ ){

/* If the segment cannot be drawn directly as a straight line, we will
   subdivide it. */
         if( !seg_ok[ i ] ){

/* Increment the number of segments being subdivided, and let the array
   of subsegment offsets grow to accomodate it. */
            statics->nseg++;
            dd = (double *) astGrow( dd, statics->nseg, sizeof(double)*( CRV_NSEG + 1 ) );
            if( !astOK ) break;

/* Append the offset to each new subsegment to the "dd" array. */
            statics->el = ( statics->nseg - 1 )*( CRV_NSEG + 1 );
            statics->d0 = d[ i ];
            for( statics->j = 0; statics->j <= CRV_NSEG; statics->j++ ){
               dd[ statics->el++ ] = statics->d0;
               statics->d0 += statics->delta;
            }
         }
      }

/* If any segments needed subdividing, get room to store the graphics
   coordinates at each point, and then fill these arrays by calling
   Crv_map to map the offsets in "dd" into graphics coordinates. */
      if( statics->nseg > 0 ){
         statics->nel = statics->nseg*( CRV_NSEG + 1 );
         xx = (double *) astMalloc( sizeof(double)*(size_t)statics->nel );
         yy = (double *) astMalloc( sizeof(double)*(size_t)statics->nel );
         Crv_map( statics->nel, dd, xx, yy, method, class, status GLOBALS_NAME );
      }
   }

/* If all has gone OK, we will draw each segment. Initialise pointers
   used to walk through the "xx", "yy" and "dd" arrays. */
   if( astOK ){
      px = xx;
      py = yy;
      pd = dd;

/* Draw each segment in turn. */
      for( i = 0; i < CRV_NSEG; i++ ){

/* If possible, draw it as a single straight line, and then store the
   unit vector along the line in the appropriate external variables for
   use by the next invocation of this function. */
         if( seg_ok[ i ] ){
            CrvLine( this, x[ i ], y[ i ], x[ i + 1 ], y[ i + 1 ], method, class, status );
            statics->dl = sqrt( dl2[ i ] );
            Crv_ux0 = dx[ i ]/statics->dl;
            Crv_uy0 = dy[ i ]/statics->dl;

/* Otherwise, if we are subdividing, and if the current segment is
   not very short, we call this function recursively to draw the segment.
   Increment pointers into the "xx", "yy" and "dd" arrays so that they
   point to the start of the subsegment information for the next segment
   to be subdivided. If all the graphics positions at this level were
   bad or outside the plot, tell the next invocation of Crv to do no
   further sub-divisions if it too finds all graphics positions to be bad or
   outside the plot. */
         } else if( subdivide ) {

#ifdef CRV_TRACE
            statics->levels[ Crv_nent ] = i;
#endif

            Crv( this, pd, px, py, statics->all_bad, bbox, statics, method,
                 class, status );
            pd += CRV_NSEG + 1;
            px += CRV_NSEG + 1;
            py += CRV_NSEG + 1;

/* Otherwise, we assume we have hit a discontinuity in the curve. Store
   bad values for the unit vector along the previous sgment, and do not
   draw anything. */
         } else {
            Crv_ux0 = AST__BAD;
            Crv_uy0 = AST__BAD;
         }
       }
    }

/* Free any memory used to store subsegment information. */
   if( dd ) dd = (double *) astFree( (void *) dd );
   if( xx ) xx = (double *) astFree( (void *) xx );
   if( yy ) yy = (double *) astFree( (void *) yy );

/* Decrement the number of recursive entries into this function. */
   Crv_nent--;

/* Free the memory holding the static data values if we are leaving the
   final entry. */
   if( ! pstatics ) statics = astFree( statics );

/* Return. */
   return;
}

static int CvBrk( AstPlot *this, int ibrk, double *brk, double *vbrk,
                     double *len, int *status ){
/*
*+
*  Name:
*     astCvBrk

*  Purpose:
*     Return information about breaks in the last curve drawn by astGridLine,
*     astCurve or astGenCurve.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot.h"
*     int CvBrk( AstPlot *this, int ibrk, double *brk, double *vbrk,
*                   double *len )

*  Class Membership:
*     Plot method.

*  Description:
*     Curves drawn by astGridLine, astCurve or astGenCurve may contain breaks
*     for several reasons (for instance, it may go outside the plotting area,
*     or the mapping between physical and graphics coordinates may be
*     discontinuous). This function returns information about such breaks.

*  Parameters:
*     this
*        Pointer to a Plot.
*     ibrk
*        The index of the break for which information is required. The first
*        break has index 1. An error is reported if no break with the
*        required index exists. The exception to this is that zero can be
*        supplied, in which case the "brk" and "vbrk" parameters
*        are ignored, but all other information is returned.
*     brk
*        A pointer to an array of 2 elements
*        in which to return the X and Y graphics coordinates of the break.
*     vbrk
*        A pointer to an array of 2 elements
*        in which to return the X and Y components of a unit vector in the
*        graphics coordinate system. The vector is tangential to the curve
*        at the requested break, and points back along the drawn section of
*        the curve.
*     len
*        A pointer to a "double" in which to return the
*        length of the drawn curve, in the graphics coordinate system.

*   Returned Value:
*     astCvBrk()
*        The number of breaks which occurred in the curve.

*  Notes:
*     -  Currently, this function may not be used to return information
*     about curves drawn using astPolyCurve.
*     -  All curves contain at least two breaks; one at the start and one
*     at the end. This is true even if the start and end of the curve are
*     coincident. However, if the entire curve was outside the plotting area
*     (i.e. if the length of the drawn curve is zero), then it will have no
*     breaks.
*     -  If no curve has yet been drawn by astGridLine or astCurve, then -1 is
*     returned for the function value, and the function parameter values are
*     left unchanged.
*     -  The returned information refers to the most recent curve drawn by
*     astGridLine or astCurve, even if that curve was drawn by a Plot other than
*     the one supplied to this function.
*     -  NULL pointers may be supplied for "brk", "vbrk" or "len", in which
*     case the corresponding values are not returned.
*     -  Zero is returned by this function if an error has already occurred,
*     or if this function should fail for any reason.

*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS   /* Pointer to thread-specific global data */
   int ret;             /* The number of breaks in the curve. */

/* Check the global status. */
   if( !astOK ) return 0;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Information about the most recent curve drawn by astGridLine or astCurve is
   stored in the external structure "Curve_data". Get the number of breaks
   in the last curve. This is initialised to -1 in astInitPlot when the
   virtual function table for this class is initialised. */
   ret = Curve_data.nbrk;

/* If a curve has been drawn, store the length of the drawn curve if
   required. */
   if( ret != -1 ){
      if( len ) *len = (double) Curve_data.length;

/* If a legal break index has been supplied, return the position and
   direction at the requested break (if required). */
      if( ibrk > 0 && ibrk <= ret ){
         if( brk ){
            brk[ 0 ] =  (double) Curve_data.xbrk[ ibrk - 1 ];
            brk[ 1 ] =  (double) Curve_data.ybrk[ ibrk - 1 ];
         }
         if( vbrk ){
            vbrk[ 0 ] =  (double) Curve_data.vxbrk[ ibrk - 1 ];
            vbrk[ 1 ] =  (double) Curve_data.vybrk[ ibrk - 1 ];
         }

/* If an illegal break index has been supplied (other than zero), report
   an error, and set the number of breaks to zero. */
      } else if( ibrk ){
         if( ret > 0 ){
            astError( AST__BDBRK, "astCvBrk(%s): The supplied break index "
                      "(%d) should be in the range [1,%d].", status, astGetClass(this),
                      ibrk, ret );
            ret = 0;
         } else {
            astError( AST__BDBRK, "astCvBrk(%s): The most recent curve "
                      "plotted by method astGridLine or astCurve had no breaks.", status,
                      astGetClass(this) );
         }
      }
    }

/* If an error has occurred, return 0. */
   if( !astOK ) ret = 0;

/* Return the result. */
   return ret;

}

static void CrvLine( AstPlot *this, double xa, double ya, double xb, double yb,
                     const char *method, const char *class, int *status ){
/*
*  Name:
*     CrvLine

*  Purpose:
*     Draw a straight line between two points, with clipping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void CrvLine( AstPlot *this, double xa, double ya, double xb, double yb,
*                   const char *method, const char *class )

*  Class Membership:
*     Plot member function.

*  Description:
*     This functions draws a straight line from (xa,ya) to (xb,yb), breaking
*     the line at the edges of the plotting area defined by Crv_xlo, Crv_xhi,
*     Crv_ylo and Crv_yhi if Crv_clip is non-zero. If the line does not start
*     at the end of the previous line plotted by this function, then
*     information describing the break in the curve is stored in external
*     arrays.

*  Parameters:
*     xa
*        The graphics X coordinate at the start of the line.
*     ya
*        The graphics Y coordinate at the start of the line.
*     xb
*        The graphics X coordinate at the end of the line.
*     yb
*        The graphics Y coordinate at the end of the line.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.

*  External Variables:
*     Crv_ink = int (Read)
*        If zero then no line is drawn even if the line intersects the
*        plotting space, but break information (etc) is still returned.
*     Crv_clip = double (Read)
*        Clip lines at boundary of plotting space?
*     Crv_xlo = double (Read)
*        Lower x limit of the plotting space.
*     Crv_xhi = double (Read)
*        Upper x limit of the plotting space.
*     Crv_ylo = double (Read)
*        Lower y limit of the plotting space.
*     Crv_yhi = double (Read)
*        Upper y limit of the plotting space.
*     Crv_tol = double (Read)
*        The tolerance for determining if 2 points are coincident.
*     Crv_out = int (Read/Write)
*        Returned as zero if the line intersects the plotting space.
*        Unchanged otherwise.
*     Crv_xbrk = float * (Read/Write)
*        Pointer to the next available element in an array of AST__PLOT_CRV_MXBRK
*        values containing the graphics X coordinates at which each break
*        in the plotted curve occurred. A break is recorded if the starting
*        point of the current line is not the same as the end point of
*        the previous line.
*     Crv_ybrk = float * (Read/Write)
*        Pointer to the next available element in an array of AST__PLOT_CRV_MXBRK
*        values containing the graphics Y coordinates at which each break
*        in the plotted curve occurred.
*     Crv_vxbrk = float * (Read/Write)
*        Pointer to the next available element in an array of AST__PLOT_CRV_MXBRK
*        values containing the X component of the unit vector (within the
*        graphics coordinate system) parallel to the tangent to the curve
*        at each break. The sense is such that the vector always points back
*        along the plotted section of the curve.
*     Crv_vybrk = float * (Read/Write)
*        Pointer to the next available element in an array of AST__PLOT_CRV_MXBRK
*        values containing the Y component of the unit vector parallel to
*        the tangent to the curve at each break.
*     Crv_nbrk = int (Write)
*        The number of breaks for which information is returned in Crv_xbrk,
*        etc.
*     Crv_len = float (Write)
*        The length of the section of the curve which has been drawn so far.
*     Crv_xl = double (Write)
*        The graphics X coordinate at the end of the last line drawn.
*     Crv_yl = double (Write)
*        The graphics Y coordinate at the end of the last line drawn.
*     Crv_vxl = double (Write)
*        The X component of the unit vector along the last line drawn.
*     Crv_vyl = double (Write)
*        The Y component of the unit vector along the last line drawn.
*     Grf_alpha = float (Read)
*        The factor for scaling graphics X axis values into equal scaled
*        X axis values.
*     Grf_beta = float (Read)
*        The factor for scaling graphics Y axis values into equal scaled
*        Y axis values.

*/

/* local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   double a1;    /* Distance from B to the lower x boundary */
   double a2;    /* Distance from B to the upper x boundary */
   double a3;    /* Distance from B to the lower y boundary */
   double a4;    /* Distance from B to the upper y boundary */
   double aamax; /* Distance from supplied point B to the plotable point A */
   double aamin; /* Distance from supplied point B to the plotable point B */
   double dl;    /* Length of plotted line segment */
   double dx;    /* Difference in x between supplied points */
   double dy;    /* Difference in y between supplied points */
   double t;     /* Temporary storage */
   double xam;   /* Modified xa position */
   double xbm;   /* Modified xb position */
   double yam;   /* Modified ya position */
   double ybm;   /* Modified yb position */
   int plot;     /* True if a line can be plotted */

/* Check inherited global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   dl = 0.0;
   xam = 0.0;
   xbm = 0.0;
   yam = 0.0;
   ybm = 0.0;

/* Store the shifts in x and y. */
   dx = xb - xa;
   dy = yb - ya;

/* Do nothing if the line is of zero length. */
   if( dx == 0.0 && dy == 0.0 ) return;

/* If either end is outside the zone, replace the given coordinates with
   the end coordinates of the section of the line which lies within the
   zone. */
   if( Crv_clip && ( xa < Crv_xlo || xa > Crv_xhi ||
                     xb < Crv_xlo || xb > Crv_xhi ||
                     ya < Crv_ylo || ya > Crv_yhi ||
                     yb < Crv_ylo || yb > Crv_yhi ) ){

/* Find the distance from point B towards point A at which the
   line cuts the two x bounds of the zone (distance at point B is
   0.0, and at point A is 1.0). */
      if( dx != 0.0 ){
         a1 = ( xb - Crv_xlo )/dx;
         a2 = ( xb - Crv_xhi )/dx;

/* Ensure that a1 represents the highest plottable offset, and a2 the
   lowest. */
         if( a1 < a2 ){
            t = a1;
            a1 = a2;
            a2 = t;
         }

/* If the line joining A and B is vertical... */
      } else {

/* If the line is within the plottable x range, indicate that all
   offsets are plottable (as far as the x range is concerned at least). */
         if( ( xa > Crv_xlo || astEQUALS( xa, Crv_xlo, 1.0E8 ) ) &&
             ( xa < Crv_xhi || astEQUALS( xa, Crv_xhi, 1.0E8 ) ) ){
            a1 = DBL_MAX;
            a2 = -DBL_MAX;

/* If the line is ouside the plottable x range, indicate that no
   offsets are plottable. */
         } else {
            a1 = 0.0;
            a2 = 0.0;
         }
      }

/* Find the fractional distance from point A to point B at which the
   line cuts the two y bounds of the zone. */
      if( dy != 0.0 ){
         a3 = ( yb - Crv_ylo )/dy;
         a4 = ( yb - Crv_yhi )/dy;

/* Ensure that a3 represents the highest plottable offset, and a4 the
   lowest. */
         if( a3 < a4 ){
            t = a3;
            a3 = a4;
            a4 = t;
         }

/* If the line joining A and B is horizontal... */
      } else {

/* If the line is within the plottable y range, indicate that all
   offsets are plottable (as far as the y range is concerned at least). */
         if( ( ya > Crv_ylo || astEQUALS( ya, Crv_ylo, 1.0E8 ) ) &&
             ( ya < Crv_yhi || astEQUALS( ya, Crv_yhi, 1.0E8 ) ) ){
            a3 = DBL_MAX;
            a4 = -DBL_MAX;

/* If the line is ouside the plottable y range, indicate that no
   offsets are plottable. */
         } else {
            a3 = 0.0;
            a4 = 0.0;
         }
      }

/* Find the fractional distances from point A to point B at the ends
   of the plotable line. */
      aamin = astMIN( 1.0, astMAX( 0.0, astMAX( a2, a4 ) ) );
      aamax = astMAX( 0.0, astMIN( 1.0, astMIN( a1, a3 ) ) );

/* Store the end coordinates of the line joining the plotable points. */
      if( aamax > aamin ){
         xam = xb - aamax*dx;
         yam = yb - aamax*dy;
         xbm = xb - aamin*dx;
         ybm = yb - aamin*dy;
         plot = 1;

/* Get the unit vector along the line and the length of the plotted section. */
         dx *= Grf_alpha;
         dy *= Grf_beta;
         dl = sqrt( dx*dx + dy*dy );
         dx /= dl;
         dy /= dl;
         dl *= astMAX( 0.0, aamax - aamin );

/* Clear the "plot" flag if the line does not intersect the plotting area. */
      } else {
         plot = 0;
      }

/* If both ends of the line are within the plotting zone, draw the whole
   line between the supplied end points. */
   } else {
      xam = xa;
      yam = ya;
      xbm = xb;
      ybm = yb;
      plot = 1;

/* Get the length of the line and the unit vector along the line. */
      dx *= Grf_alpha;
      dy *= Grf_beta;
      dl = sqrt( dx*dx + dy*dy );
      dx /= dl;
      dy /= dl;
    }

/* If a line is to be plotted... */
   if( plot ){

/* If this is the first line to be plotted in the current curve, save
   the start of the line as a break, and indicate that some of the curve
   falls within the plotting zone. */
      if( Crv_out ){
         Crv_nbrk = 1;
         *(Crv_xbrk++) = (float) xam;
         *(Crv_ybrk++) = (float) yam;
         *(Crv_vxbrk++) = (float) dx;
         *(Crv_vybrk++) = (float) dy;
         Crv_out = 0;

/* Set the length of the curve plotted so far to the length of this first
   segment. */
         Crv_len = (float) dl;

/* Start a poly line. */
         if( Crv_ink ) Bpoly( this, (float) xam,  (float) yam, status );

/* If this is not the first line to be plotted... */
      } else {

/* ... increment the length of the curve plotted so far. */
         Crv_len += (float) dl;

/* If the start of this line is not coincident with the end
   of the previous line, save the previous and current positions as
   breaks in the curve. Note, the previous vector is reversed so that
   it points back towards the drawn section of the curve. Report an
   error if the arrays are full. */
         if( fabs( xam - Crv_xl ) > Crv_tol ||
             fabs( yam - Crv_yl ) > Crv_tol ){
            Crv_nbrk += 2;
             if( Crv_nbrk > AST__PLOT_CRV_MXBRK ){
               astError( AST__CVBRK, "%s(%s): Number of breaks in plotted "
                         "curve exceeds %d.", status, method, class, AST__PLOT_CRV_MXBRK );
            } else {
               *(Crv_xbrk++) = (float) Crv_xl;
               *(Crv_ybrk++) = (float) Crv_yl;
               *(Crv_vxbrk++) = (float) -Crv_vxl;
               *(Crv_vybrk++) = (float) -Crv_vyl;
                *(Crv_xbrk++) = (float) xam;
               *(Crv_ybrk++) = (float) yam;
               *(Crv_vxbrk++) = (float) dx;
               *(Crv_vybrk++) = (float) dy;
            }

/* Start a poly line. */
            if( Crv_ink ) Bpoly( this, (float) xam,  (float) yam, status );
          }
      }

/* Append a section to the current poly line. */
      if( Crv_ink ) Apoly( this, (float) xbm,  (float) ybm, status );

/* Save the position and vector at the end of the current line. */
      Crv_xl = xbm;
      Crv_yl = ybm;
      Crv_vxl = dx;
      Crv_vyl = dy;
    }

/* Return. */
   return;
}


static void Curve( AstPlot *this, const double start[],
                                  const double finish[], int *status ){
/*
*++
*  Name:
c     astCurve
f     AST_CURVE

*  Purpose:
*     Draw a geodesic curve.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astCurve( AstPlot *this, const double start[],
c                                   const double finish[] )
f     CALL AST_CURVE( THIS, START, FINISH, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function draws a geodesic curve between two points in the
f     This routine draws a geodesic curve between two points in the
*     physical coordinate system of a Plot.  The curve drawn is the
*     path of shortest distance joining the two points (as defined by
c     the astDistance function for the current Frame of the Plot).
f     the AST_DISTANCE function for the current Frame of the Plot).
*     For example, if the current Frame is a basic Frame, then the
*     curve joining the two points will be a straight line in physical
*     coordinate space.  If the current Frame is more specialised and
*     describes, for instance, a sky coordinate system, then the
*     geodesic curve would be a great circle in physical coordinate
*     space passing through the two sky positions given.
*
*     Note that the geodesic curve is transformed into graphical
*     coordinate space for plotting, so that a straight line in
*     physical coordinates may result in a curved line being drawn if
*     the Mapping involved is non-linear. Any discontinuities in the
*     Mapping between physical and graphical coordinates are
c     catered for, as is any clipping established using astClip.
f     catered for, as is any clipping established using AST_CLIP.
*
c     If you need to draw many geodesic curves end-to-end, then the
c     astPolyCurve function is equivalent to repeatedly using
c     astCurve, but will usually be more efficient.
f     If you need to draw many geodesic curves end-to-end, then the
f     AST_POLYCURVE routine is equivalent to repeatedly calling
f     AST_CURVE, but will usually be more efficient.
*
c     If you need to draw curves which are not geodesics, see astGenCurve
c     or astGridLine.
f     If you need to draw curves which are not geodesics, see AST_GENCURVE
f     or AST_GRIDLINE.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     start
f     START( * ) = DOUBLE PRECISION (Given)
*        An array, with one element for each axis of the Plot, giving
*        the physical coordinates of the first point on the geodesic
*        curve.
c     finish
f     FINISH( * ) = DOUBLE PRECISION (Given)
*        An array, with one element for each axis of the Plot, giving
*        the physical coordinates of the second point on the geodesic
*        curve.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
c     - No curve is drawn if either of the "start" or "finish" arrays
c     contains any coordinates with the value AST__BAD.
f     - No curve is drawn if either of the START or FINISH arrays
f     contains any coordinates with the value AST__BAD.
*     - An error results if the base Frame of the Plot is not 2-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*--
*/
/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   int naxes;              /* No. of axes in the base Frame */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astCurve";
   class = astGetClass( this );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Initialise the bounding box for primitives produced by this call. */
   if( !Boxp_freeze ) {
      Boxp_lbnd[ 0 ] = FLT_MAX;
      Boxp_lbnd[ 1 ] = FLT_MAX;
      Boxp_ubnd[ 0 ] = FLT_MIN;
      Boxp_ubnd[ 1 ] = FLT_MIN;
   }

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Draw the curve. The break information is stored in an external structure
   where it can be accessed by public methods which return information
   about the most recently drawn curve. */
   CurvePlot( this, start, finish, 1, &Curve_data, method, class, status );

/* Ensure all lines are flushed to the graphics system. */
   Fpoly( this, method, class, status );

/* Return. */
   return;
}

static void CurvePlot( AstPlot *this, const double *start, const double *finish,
                     int ink, AstPlotCurveData *cdata, const char *method,
                     const char *class, int *status ){
/*
*
*  Name:
*     CurvePlot

*  Purpose:
*     Draw a geodesic curve.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void CurvePlot( AstPlot *this, const double *start, const double *finish,
*                   int ink, AstPlotCurveData *cdata, const char *method,
*                   const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws a geodesic curve between the supplied starting and
*     finishing positions. The algorithm used can handle discontinuities in the
*     Mapping between the current Frame and graphics coordinates, and
*     information describing any breaks in the curve (including the start and
*     end of the curve) are returned in the supplied AstPlotCurveData structure.

*  Parameters:
*     this
*        Pointer to the Plot.
*     start
*        A pointer to a an array holding the coordinates of the start of the
*        curve within the current Frame of the Plot.
*     finish
*        A pointer to a an array holding the coordinates of the finish of the
*        curve within the current Frame of the Plot.
*     ink
*        If zero, the curve is not actually drawn, but information about
*        the breaks is still returned. If non-zero, the curve is also drawn.
*     cdata
*        A pointer to a structure in which to return information about the
*        breaks in the curve.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  No curve is draw if the "start" or "finish" arrays contains any bad
*     values, or if a NULL pointer is supplied for "cdata". No errors are
*     reported in these cases.
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   double d[ CRV_NPNT ];   /* Offsets to evenly spaced points along curve */
   double x[ CRV_NPNT ];   /* X coords at evenly spaced points along curve */
   double y[ CRV_NPNT ];   /* Y coords at evenly spaced points along curve */
   double tol;             /* Absolute tolerance value */
   int i;                  /* Loop count */
   int naxes;              /* No. of axes in the base Frame */
   int ok;                 /* Are all start coords good? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Get the number of axes in the current Frame. */
   naxes = astGetNout( this );

/* Check the "start" and "finish" parameter for bad values. */
   ok = 1;
   for( i = 0; i < naxes; i++ ) {
      if( start[ i ] == AST__BAD || finish[ i ] == AST__BAD ){
         ok = 0;
         break;
      }
   }

/* Check that the "cdata" pointer can be used. */
   if( !cdata ) ok = 0;

/* Only proceed if the parameters are OK, and there has been no error. */
   if( ok && astOK ){

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
      astGrfAttrs( this, AST__CURVE_ID, 1, GRF__LINE, method, class );

/* Ensure the globals holding the scaling from graphics coords to equally
   scaled coords are available. */
      GScales( this, NULL, NULL, method, class, status );

/* Set up the externals used to communicate with the Map3 function...
   The number of axes in the physical coordinate system (i.e. the current
   Frame). */
      Map3_ncoord = naxes;

/* A pointer to the Plot, the Curretn Frame, and and Mapping. */
      Map3_plot = this;
      Map3_frame = astGetFrame( this, AST__CURRENT );
      Map3_map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* The physical coordinates at the start of the curve. */
      Map3_origin = start;

/* The physical coordinates at the end of the curve. */
      Map3_end = finish;

/* The scale factor to convert "dist" values into physical offset values. */
      Map3_scale = astDistance( Map3_frame, start, finish );

/* Convert the tolerance from relative to absolute graphics coordinates. */
      tol = astGetTol( this )*astMAX( this->xhi - this->xlo,
                                      this->yhi - this->ylo );

/* Now set up the external variables used by the Crv and CrvLine function. */
      Crv_scerr = ( astGetLogPlot( this, 0 ) ||
                    astGetLogPlot( this, 1 ) ) ? 100.0 : 1.5;
      Crv_ux0 = AST__BAD;
      Crv_tol = tol;
      Crv_limit = 0.5*tol*tol;
      Crv_map = Map3;
      Crv_ink = ink;
      Crv_xlo = this->xlo;
      Crv_xhi = this->xhi;
      Crv_ylo = this->ylo;
      Crv_yhi = this->yhi;
      Crv_out = 1;
      Crv_xbrk = cdata->xbrk;
      Crv_ybrk = cdata->ybrk;
      Crv_vxbrk = cdata->vxbrk;
      Crv_vybrk = cdata->vybrk;
      Crv_clip = astGetClip( this ) & 1;

/* Set up a list of points spread evenly over the curve. */
      for( i = 0; i < CRV_NPNT; i++ ){
        d[ i ] = ( (double) i)/( (double) CRV_NSEG );
      }

/* Map these points into graphics coordinates. */
      Map3( CRV_NPNT, d, x, y, method, class, status GLOBALS_NAME );

/* Use Crv and Map3 to draw the curve. */
      Crv( this, d, x, y, 0, NULL, NULL, method, class, status );

/* End the current poly line. */
      Opoly( this, status );

/* Tidy up the static data used by Map3. */
      Map3( 0, NULL, NULL, NULL, method, class, status GLOBALS_NAME );

/* If no part of the curve could be drawn, set the number of breaks and the
   length of the drawn curve to zero. */
      if( Crv_out ) {
         Crv_nbrk = 0;
         Crv_len = 0.0F;

/* Otherwise, add an extra break to the returned structure at the position of
   the last point to be plotted. */
      } else {
         Crv_nbrk++;
         if( Crv_nbrk > AST__PLOT_CRV_MXBRK ){
            astError( AST__CVBRK, "%s(%s): Number of breaks in curve "
                      "exceeds %d.", status, method, class, AST__PLOT_CRV_MXBRK );
         } else {
            *(Crv_xbrk++) = (float) Crv_xl;
            *(Crv_ybrk++) = (float) Crv_yl;
            *(Crv_vxbrk++) = (float) -Crv_vxl;
            *(Crv_vybrk++) = (float) -Crv_vyl;
         }
      }

/* Store extra information about the curve in the returned structure, and
   purge any zero length sections. */
      if( cdata ){
         cdata->length = Crv_len;
         cdata->out = Crv_out;
         cdata->nbrk = Crv_nbrk;
         PurgeCdata( cdata, status );
      }

/* Annul the Frame and Mapping. */
      Map3_frame = astAnnul( Map3_frame );
      Map3_map = astAnnul( Map3_map );

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, AST__CURVE_ID, 0, GRF__LINE, method, class );

   }

/* Return. */
   return;

}


static AstPointSet *DefGap( AstPlot *this, double *gaps, int *ngood,
                            double *frac, int *inval, const char *method,
                            const char *class, int *status ){
/*
*  Name:
*     DefGap

*  Purpose:
*     Find default gap sizes for the tick marks on the axes of a 2-D
*     physical coordinate system.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     AstPointSet *DefGap( AstPlot *this, double *gaps, int *ngood,
*                          double *frac, int *inval, const char *method,
*                          const char *class, int *status  )

*  Class Membership:
*     Plot method.

*  Description:
*     This function returns default gap sizes for each axis in a 2-D Frame.
*     The values are found by first obtaining a grid of points spread over
*     the region containing good physical coordinates. The physical
*     coordinate values (non-normalized) for each axis are sorted into
*     increasing order.
*
*     For linearly spaced tick marks, a set of quantile axis values is then
*     found, and the median of the gaps between these quantiles is returned
*     as the default gap for the axis.
*
*     For logarithmically spaced tick marks, the returned gap size is the
*     ratio between adjacent tick mark values, chosen to give an optimal
*     number of ticks between the maximum and minimum axis values found in
*     the grid.

*  Parameters:
*     this
*        Pointer to a Plot.
*     gaps
*        Pointer to an array in which to return the default gap value for
*        each axis.
*     ngood
*        Pointer to an array in which toi return the number of good
*        values in the returned PointSet for each axis.
*     frac
*        Pointer to a double in which to return the fraction of the
*        plotting area containing good physical coordinates.
*     inval
*        Pointer to a location at which to return a flag indicating if
*        any bad physical coordinates were encountered.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a PointSet holding the physical coordinate values at a
*     set of points spread across the plotting area. The values on each
*     axis are sorted into increasing order. The values will not have
*     been normalized.

*  Notes:
*     -  The returned PointSet should be annulled when no longer needed.
*     -  This function assumes that the physical coordinate system is 2
*     dimensional, and it should not be used if this is not the case.
*     -  Gap sizes of 1.0, zero good points, and a NULL pointer are returned
*     if an error has already occurred, or if this function should fail for
*     any reason.

*/

/* Local Variables: */
   AstPointSet *pset1;        /* Pointer to PointSet holding graphics coords */
   AstPointSet *pset2;        /* Pointer to PointSet holding physical coords */
   double **ptr2;             /* Pointer to physical axis values */
   double dran;               /* Dynamic range */
   double maxv;               /* Maximum axis value */
   double minv;               /* Minimum axis value */
   double qgap[ MAJTICKS_OPT ];/* Gaps between physical coordinate quantiles */
   int dim;                   /* Dimension of grid */
   int dk;                    /* The number of points between quantiles */
   int i;                     /* The quantile index */
   int j;                     /* Axis index */
   int k;                     /* Index into the sorted array of axis values */
   int logticks;              /* Logarithmically spaced tick marks? */
   int n;                     /* Target number fo ticks */
   int psize;                 /* Total number of axis value */

/* Initialise the returned values. */
   gaps[ 0 ] = 1.0;
   gaps[ 1 ] = 1.0;
   ngood[ 0 ] = 0;
   ngood[ 1 ] = 0;
   *frac = 0.0;
   *inval = 0;

/* Check global status. */
   if( !astOK ) return NULL;

/* Get two PointSets, one holding a grid of 2D graphics coordinates,
   and one holding the corresponding (non-normalized) physical
   coordinates. */
   dim = 0;
   *frac = GoodGrid( this, &dim, &pset1, &pset2, method, class, status );

/* Get pointers to the data values in each PointSet. */
   ptr2 = astGetPoints( pset2 );

/* Store the number of elements in each PointSet. */
   psize = astGetNpoint( pset1 );

/* For each axis... */
   for( j = 0; j < 2 && astOK; j++ ){

/* Sort the axis values into increasing order. Any bad values are stored at
   the end of the array on return. */
      qsort( (void *) ptr2[ j ], (size_t) psize, sizeof(double), Compared );

/* Count the number of non-bad values returned. */
      ngood[ j ] = CountGood( psize, ptr2[ j ], status );

/* Set the returned flag to indicate if any bad values were found. */
      if( ngood[ j ] < psize ) *inval = 1;

/* Report an error if there are too few good points. */
      if( ngood[ j ] < MAJTICKS_OPT ){
         astError( AST__VSMAL, "%s(%s): The range of coordinate values "
                   "covered by axis %d is too small to plot.", status, method,
                   class, j + 1 );
         break;
      }

/* Get the maximum and minimum axis value */
      minv = ptr2[ j ][ 0 ];
      maxv = ptr2[ j ][ ngood[ j ] - 1 ];

/* See if ticks on this axis are spaced linearly or logarithmically. If a
   value has been set for LogTicks used it, otherwise find a default value.
   The default is 0 unless LogPlot is non-zero, the axis range does not
   encompass zero and and the dynamic range is 90 or more. Set this
   default value explicitly so that later functions will pick it up (it will
   be cleared at the end of the astGrid function). */
      if( astTestLogTicks( this, j ) ) {
         logticks = astGetLogTicks( this, j );
      } else {
         logticks = 0;
         if( astGetLogPlot( this, j ) && minv*maxv > 0.0 ) {
            dran = maxv/minv;
            if( dran >= 90.0 || dran <= 1.0/90.0 ) logticks = 1;
         }
         astSetLogTicks( this, j, logticks );
      }

/* If no value has been supplied for LogLabel use the value of LogTicks
   as the default. */
      if( !astTestLogLabel( this, j ) ) astSetLogLabel( this, j, logticks );

/* For linear gaps, find the gaps between adjacent evenly spaced quantiles.
   The number of quantiles used equals the optimal number of major tick
   marks. */
      if( !logticks ) {
         dk = (int)( (double)ngood[ j ]/MAJTICKS_OPT );
         i = 0;
         for( k = dk; k < ngood[ j ] && i < MAJTICKS_OPT; k += dk ){
            qgap[ i++ ] = ptr2[ j ][ k ] - ptr2[ j ][ k - dk ];
         }

/* Find the median of the gaps between adjacent quantiles. */
         qsort( (void *) qgap, (size_t) i, sizeof(double), Compared );
         gaps[ j ] = qgap[ i/2 ];

/* If the test gap size is zero, use a fraction of the total range. Report
   an error if the total range is zero. */
         if( gaps[ j ] <= 0.0 ){
            gaps[ j ] = ( ptr2[ j ][ ngood[ j ] - 1 ] - ptr2[ j ][ 0 ] )/MAJTICKS_OPT;;
            if( gaps[ j ] <= 0.0 ){
               astError( AST__VSMAL, "%s(%s): The range of coordinate values "
                         "covered by axis %d is too small to plot.", status, method,
                         class, j + 1 );
            }
         }

/* For logarithmic gaps, use the Nth root of the ratio of the maximum and
   minimum data value found. */
      } else if( astOK ) {

/* Report an error if the max and min values are of opposite signs or
   zero or equal. */
         if( maxv*minv <= 0.0 ) {
            astError( AST__ZERAX, "%s(%s): The range of coordinate values "
                         "covered by axis %d includes the origin and so "
                         "logarithmic ticks cannot be produced.", status, method,
                         class, j + 1 );

         } else if( maxv == minv ) {
            astError( AST__VSMAL, "%s(%s): The range of coordinate values "
                      "covered by axis %d is too small to plot.", status, method,
                      class, j + 1 );

/* Otherwise find the gap to use. */
         } else {

/* Store the maximum and minimum number of major tick marks along each
   axis. These numbers are reduced if only a small part of the plotting
   area contains valid coordinates, so that the tick marks do not end up
   to close together. */
            n = (int) ( 0.5 + MAJTICKS_OPT*sqrt( *frac ) );
            if( n < 5 ) n = 5;

/* Choose a gap size which makes this many gaps. */
            gaps[ j ] = pow( maxv/minv, 1.0/( n - 1.0 ) );
         }
      }
   }

/* Annul the PointSet holding Graphics coordinates. */
   pset1 = astAnnul( pset1 );

/* If an error has occurred, annul the PointSet holding physical
   coordinates, and return gaps of 1.0. */
   if( !astOK ) {
      pset2 = astAnnul( pset2 );
      gaps[ 0 ] = 1.0;
      gaps[ 1 ] = 1.0;
      ngood[ 0 ] = 0;
      ngood[ 1 ] = 0;
      *frac = 0.0;
      *inval = 0;
   }

/* Return the physical PointSet. */
   return pset2;

}

static void DrawAxis( AstPlot *this, TickInfo **grid, double *labelat,
                      double *gap, const char *method, const char *class, int *status ){
/*
*
*  Name:
*     DrawAxis

*  Purpose:
*     Draw a curve joining the major tick marks.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void DrawAxis( AstPlot *this, TickInfo **grid, double *labelat,
*                    double *gap, const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws a curve through interior tick marks on both axes.
*     The curve is drawn even if it has already been drawn as part of a
*     grid of curves, because it may have been assigned different graphics
*     attributes to the grid curves.

*  Parameters:
*     this
*        A pointer to the Plot.
*     grid
*        A pointer to an array of two TickInfo pointers (one for each axis),
*        each pointing to a TickInfo structure holding information about
*        tick marks on the axis. See function GridLines.
*     labelat
*        A pointer to a 2 element array giving the constant axis values at
*        which tick marks are put. Element 0 should give the axis 1 value at
*        which tick marks for axis 0 are placed. Element 1 should give the
*        axis 0 value at which tick marks for axis 1 are placed.
*     gap
*        Pointer to array of two values holding the gap between major
*        tick marks on the two axes.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  This function assumes the current Frame of the Plot is 2
*     dimensional, and it should not be called if this is not the case.

*/

/* Local Variables: */
   AstFrame *frm;         /* Pointer to current Frame */
   AstPlotCurveData cdata;/* Somewhere to put the unneeded curve information */
   TickInfo *info;        /* Pointer to the TickInfo for the current axis */
   double *value;         /* Current tick value */
   double bot;            /* Lowest axis value to be displayed */
   double diff;           /* Difference between adjacent tick marks */
   double udiff;          /* Used section length */
   double start[ 2 ];     /* The start of the curve in physical coordinates */
   double tmp;            /* Temporary storage */
   double top;            /* Highest axis value to be displayed */
   int axis;              /* Current axis index */
   int axisid;            /* ID value for current axis plotting attributes */
   int logticks;          /* Are major ticks spaced logarithmically? */
   int tick;              /* Current tick index */

/* Check the global status. */
   if( !astOK ) return;

/* Not the id value for the first axis. */
   axisid = AST__AXIS1_ID;

/* Get a pointer to the current Frame. */
   frm = astGetFrame( this, AST__CURRENT );

/* Consider drawing a curve parallel to each axis in turn. */
   for( axis = 0; axis < 2; axis++ ){

/* Establish the correct graphical attributes for this axis as defined by
   attributes with the supplied Plot. */
      astGrfAttrs( this, axisid, 1, GRF__LINE, method, class );

/* Check the axis is required. */
      if( astGetDrawAxes( this, axis ) ){

/* If the tick marks have been placed round the edges of the plotting
   area, we do not need to draw the curves. */
         if( labelat[ axis ] != AST__BAD ){

/* Get the max and min values allowed on this axis. */
            bot = astGetBottom( frm, axis );
            top = astGetTop( frm, axis );
            if( bot > top ) {
               tmp = top;
               top = bot;
               bot = tmp;
            }

/* Get a pointer to the structure containing information describing the
   positions of the major tick marks along the current axis. */
            info = grid[ axis ];

/* Get a pointer to the axis value at the first major tick mark. */
            value = info->ticks;

/* See if the major tick marks are logarithmically spaced on this axis. */
            logticks = astGetLogTicks( this, axis );

/* Initialise the difference between major tick marks. */
            diff = logticks ? 0.0 : gap[ axis ];

/* Loop round all ticks. */
            for( tick = 0; tick < info->nmajor; tick++, value++ ){

/* Update the difference between major tick marks if we are producing
   logarithmically spaced ticks (in which "gap" is a ratio, not a
   difference). */
               if( logticks ) diff = (*value)*( gap[ axis ] - 1.0 );

/* Note the starting point for this section. */
               start[ axis ] = *value;
               start[ 1 - axis ] = labelat[ axis ];

/* If this is the first tick, draw an axis section going "backwards" in
   case the first tick isn't at the lower visible bound. Limit the length
   of this backwards section so that it does not extend beyond the minimum
   axis value. */
               if( tick == 0 ) {
                  udiff = *value - bot;
                  if( udiff > diff ) udiff = diff;
                  if( udiff > 0.0 ) {
                     AxPlot( this, axis, start, -udiff, 1, &cdata, method,
                             class, status );
                  }
               }

/* Limit the length of the section so that it does not extend beyond the
   maximum axis value. */
               udiff = ( *value + diff > top ) ? top - *value : diff;

/* Do not draw zero length sections. */
               if( udiff > 0.0 ) {

/* Draw a curve parallel to the current axis, starting at the tick mark,
   with length equal to the gap between tick marks. Do not draw sections
   of the curve which are outside the primary domains of the physical axes. */
                  AxPlot( this, axis, start, udiff, 1, &cdata, method,
                          class, status );
               }

            }

/* Once the last section has been drawn, draw another axis section in case the
   last tick isn't at the upper visible bound. Limit the length of this
   section so that it does not extend beyond the maximum axis value. */
            udiff = top - start[ axis ];
            if( udiff > diff ) udiff = diff;
            if( udiff > 0.0 ) {
               AxPlot( this, axis, start, udiff, 1, &cdata, method,
                       class, status );
            }
         }
      }

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, axisid, 0, GRF__LINE, method, class );

/* Set up the id value for the next axis. */
      axisid = AST__AXIS2_ID;

   }

/* Free the pointer to the current Frame. */
   frm = astAnnul( frm );

}


static AstPlotCurveData **DrawGrid( AstPlot *this, TickInfo **grid, int drawgrid,
                             const char *method, const char *class, int *status ){
/*
*  Name:
*     DrawGrid

*  Purpose:
*     Draw a grid of lines at the major tick mark positions on both axes.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     AstPlotCurveData **DrawGrid( AstPlot *this, TickInfo **grid, int drawgrid,
*                           const char *method, const char *class )

*  Class Membership:
*     Plot method.

*  Description:
*     This function draw a grid of curves at the major tick mark
*     positions on both axes, and returns information describing the
*     breaks in the curves. If short tick marks are required rather
*     than long curves (as specified by the Grid attribute of the supplied
*     Plot), then the curves are not drawn but the break information is
*     still returned.

*  Parameters:
*     this
*        Pointer to a Plot.
*     grid
*        A pointer to an array of two pointers (one for each axis), each
*        pointing to a TickInfo structure. These describe the positions
*        of the tick marks and should have been produced by function
*        GridLines.
*     drawgrid
*        If non-zero, draw a grid of curves marking the major axis
*        values. Otherwise, tick marks will be drawn at these values later.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.

*  Returned Value:
*     A pointer to an array of two AstPlotCurveData pointers (one for each axis),
*     each pointing to an array of AstPlotCurveData structures (one for each tick
*     value).

*  Notes:
*     -  This function assumes that the physical coordinate system is 2
*     dimensional, and it should not be used if this is not the case.
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned.

*/

/* Local Variables: */
   AstPlotCurveData **cdata;/* The returned pointer */
   AstPlotCurveData *cdt;   /* Pointer to break info. for current tick mark */
   AstPlotCurveData tcdt;   /* Pointer to break info. for current curve section */
   TickInfo *info;          /* Tick mark information for a single axis */
   double start[ 2 ];       /* Strting position for current curve section */
   double total_length;     /* Total curve length for all axis ticks */
   int i;                   /* Axis index */
   int j;                   /* Tick mark index */
   int k;                   /* Curve section index */

/* Check the global status. */
   if( !astOK ) return NULL;

/* Allocate memory to hold two pointers, each pointing to an array of
   AstPlotCurveData structure. */
   cdata = (AstPlotCurveData **) astMalloc( 2*sizeof( AstPlotCurveData *) );

/* If succesful, initialise the pointers. */
   if( astOK ){
      cdata[ 0 ] = NULL;
      cdata[ 1 ] = NULL;

/* Draw the curves marking the major tick values on each axis. If no grid is
   required, we still do this in order to get information about the breaks
   in the curves which will be used later to decide where to put the labels,
   but we use "invisible ink". */
      for( i = 0; i < 2; i++ ){

/* Get a pointer to the TickInfo structure for this axis holding information
   about where to put tick marks on this axis. */
         info = grid[ i ];

/* Allocate memory to hold information describing the breaks in each tick
   mark curve. This takes the form of an array of AstPlotCurveData structures,
   one for each tick mark. */
         cdata[ i ] = (AstPlotCurveData *) astMalloc( sizeof(AstPlotCurveData)*
                                               (size_t) info->nmajor );

/* Check the pointer can be used. */
         if( astOK ){

/* Initialise a pointer to the first AstPlotCurveData structure for this axis. */
            cdt = cdata[ i ];
            total_length = 0.0;

/* Do each tick mark. */
            for( j = 0; j < info->nmajor; j++ ){

/* Store the starting point of the first section of the curve. */
               start[ i ] = (info->ticks)[ j ];
               start[ 1 - i ] = (info->start)[ 0 ];

/* Draw the first section of the curve parallel to the other axis, starting
   at the values in "start", and extending for a length given in the TickInfo
   structure. We use invisible ink if short tick marks are required instead
   of a grid of curves. */
               AxPlot( this, 1 - i, start, (info->length)[ 0 ],
                       drawgrid, cdt, method, class, status );

/* Now draw any other sections in the curve. */
               for( k = 1; k < info->nsect; k++ ){

/* Modify the starting value on the other axis. The starting value on
   the current axis remains set to the tick mark value. */
                  start[ 1 - i ] = (info->start)[ k ];

/* Draw the curve, the information describing the breaks goes into
   temporary storage in the local structure "tcdt". */
                  AxPlot( this, 1 - i, start, (info->length)[ k ],
                          drawgrid, &tcdt, method, class, status );

/* Concatenate the break information for this section with the break
   information describing the previous sections. */
                  AddCdt( cdt, &tcdt, method, class, status );

               }

/* Increment the total length of curves drawn for all ticks on this axis. */
               total_length += cdt->length;

/* Point to the AstPlotCurveData structure for the next tick mark. */
               cdt++;

            }

/* Report an error if the total length of all curves on this axis is zero.
   This can be caused for instance by bugs in the algorithm for finding
   major tick values (which may cause AST__BAD tick mark values). */
            if( total_length == 0.0 && astOK ) {
               astError( AST__INTER, "%s(%s): No grid curves can be drawn for "
                         "axis %d.", status, method, class, i + 1 );
            }

         }

      }

   }

/* If an error has occurred, clean up the returned structures. */
   if( !astOK ) cdata = CleanCdata( cdata, status );

/* Return. */
   return cdata;

}

static int DrawRegion( AstPlot *this, AstFrame *frm, const char *method,
                       const char *class, int *status ){
/*
*
*  Name:
*     DrawRegion

*  Purpose:
*     Draw the outline of a Region.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int DrawRegion( AstPlot *this, AstFrame *frm, const char *method,
*                     const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     If the current Frame in the supplied Plot is a Region, this function
*     draws a curve marking the outline of the Region. It returns without
*     action otherwise.

*  Parameters:
*     this
*        Pointer to the Plot.
*     frm
*        Pointer to the current Frame in the Plot (possibly a Region).
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Non-zero if and only if a Region outline was drawn.

*/

/* Local Variables: */
   AstMapping *map;        /* Mapping with Region masking included */
   AstPlotCurveData cdata; /* Stores information about curve breaks */
   AstRegion **comps;      /* List of component Regions */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   double d[ CRV_NPNT ];   /* Offsets to evenly spaced points along curve */
   double tol;             /* Absolute tolerance value */
   double x[ CRV_NPNT ];   /* X coords at evenly spaced points along curve */
   double y[ CRV_NPNT ];   /* Y coords at evenly spaced points along curve */
   int i;                  /* Loop count */
   int icomp;              /* Index of component Region */
   int ncomp;              /* Number of component Regions */
   int result;             /* The returned value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Check the current Frame is a Region, and is of a class that implements
   the astRegTrace method. */
   if( astIsARegion( frm ) &&
       astRegTrace( (AstRegion *) frm, 0, NULL, NULL ) ){

/* Set up the externals used to communicate with the Map5 function...
   The number of axes in the physical coordinate system (i.e. the
   Region). */
      Map5_ncoord =  astGetNaxes( frm );

/* A pointer to the Plot. */
      Map5_plot = this;

/* Also store a pointer to the Mapping, ensuring that the Mapping does
   not contain any masking effects from the Region. */
      map = astGetMapping( this, AST__BASE, AST__CURRENT );
      Map5_map = astRemoveRegions( map );
      map = astAnnul( map );

/* Convert the tolerance from relative to absolute graphics coordinates.
   Make the tolerance smaller by a factor of 10 because Regions
   (specifically Polygonsd) can have very crinkly edges. */
      tol = 0.1* astGetTol( this )*astMAX( this->xhi - this->xlo,
                                           this->yhi - this->ylo );

/* Ensure the globals holding the scaling from graphics coords to equally
   scaled coords are available. */
      GScales( this, NULL, NULL, method, class, status );

/* Now set up the external variables used by the Crv and CrvLine function. */
      Crv_scerr = ( astGetLogPlot( this, 0 ) ||
                    astGetLogPlot( this, 1 ) ) ? 100.0 : 1.5;
      Crv_ux0 = AST__BAD;
      Crv_tol = 2*tol;
      Crv_limit = 0.5*tol*tol;
      Crv_map = Map5;
      Crv_ink = 1;
      Crv_xlo = this->xlo;
      Crv_xhi = this->xhi;
      Crv_ylo = this->ylo;
      Crv_yhi = this->yhi;
      Crv_out = 1;
      Crv_xbrk = cdata.xbrk;
      Crv_ybrk = cdata.ybrk;
      Crv_vxbrk = cdata.vxbrk;
      Crv_vybrk = cdata.vybrk;
      Crv_clip = astGetClip( this ) & 1;

/* Attempt to split the Region into a set of disjoint component Regions. */
      comps = astRegSplit( (AstRegion *) frm, &ncomp );

/* Draw each one. */
      for( icomp = 0; icomp < ncomp; icomp++ ) {

/* A pointer to the Region. */
         Map5_region = comps[ icomp ];

/* Set up a list of points spread evenly over the curve. */
         for( i = 0; i < CRV_NPNT; i++ ){
           d[ i ] = ( (double) i)/( (double) CRV_NSEG );
         }

/* Map these points into graphics coordinates. */
         Map5( CRV_NPNT, d, x, y, method, class, status GLOBALS_NAME );

/* Use Crv and Map5 to draw the curve. */
         Crv( this, d, x, y, 0, NULL, NULL, method, class, status );

/* End the current poly line. */
         Opoly( this, status );

/* Tidy up the static data used by Map5. */
         Map5( 0, NULL, NULL, NULL, method, class, status GLOBALS_NAME );

/* Annul the component Region pointer. */
         comps[ icomp ] = astAnnul( Map5_region );
      }

/* Free the memory holding the list of component Region pointers. */
      comps = astFree( comps );

/* Annul the Mapping. */
      Map5_map = astAnnul( Map5_map );

/* Indicate the outline was drawn. */
      result = 1;
   }

/* Return. */
   return result;
}

static void DrawText( AstPlot *this, int ink, int esc, const char *text,
                      float x, float y, const char *just, float upx,
                      float upy, float *xbn, float *ybn, float *drop,
                      const char *method, const char *class, int *status ){
/*
*  Name:
*     DrawText

*  Purpose:
*     Draw a character string, potentially including superscripts and
*     subscripts.

*  Synopsis:
*     #include "plot.h"
*     void DrawText( AstPlot *this, int ink, int esc, const char *text,
*                    float x, float y, const char *just, float upx,
*                    float upy, float *xbn, float *ybn, float *drop,
*                    const char *method, const char *class, int *status )

*  Description:
*     This function displays a character string at a given position
*     using a specified up-vector, optionally interpreting any Plot escape
*     sequences contained within the text. It also returns its bounding
*     box.

*  Parameters:
*     this
*        The plot.
*     ink
*        If zero, nothing is drawn but the bounding box is still returned.
*     esc
*        Should escape sequences be interpreted? They will be printed
*        literally otherwise.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The graphics X coordinate of the label's reference point.
*     y
*        The graphics Y coordinate of the label's reference point.
*     just
*        Pointer to a null-terminated character string identifying the
*        reference point for the text being drawn. The first character in
*        this string identifies the reference position in the "up" direction
*        and may be "M", "B", "C" or "T" (for bottom, baseline, centre or
*        top). The second character identifies the side-to-side reference
*        position and may be "L", "C" or "R" (for left, centre or right). The
*        string is case-insensitive, and only the first two characters are
*        significant.
*     upx
*        The x component of the up-vector for the text. Positive values
*        always refer to displacements from left to right on the screen,
*        even if the graphics x axis increases in the opposite sense.
*     upy
*        The y component of the up-vector for the text. Positive values
*        always refer to displacements from left to right on the screen,
*        even if the graphics y axis increases in the opposite sense.
*     xbn
*        An array in which is returned the x coordinates at the corners
*        of the bounding box. The order is: bottom left, top left, top
*        right, bottom right.
*     ybn
*        An array in which is returned the Y coordinates at the corners
*        of the bounding box (see xbn).
*     drop
*        Address of a float in which to return the distance between the
*        bottom of the bounding box and the baseline of normal text. May
*        be NULL.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  The "B" option for the justification in the "up" direction refers
*     to the base-line on which the text is written. Some characters
*     ("y", "p", "g", etc) descend below this line. In addition, if the
*     supplied text string includes any escape sequences which produce
*     sub-scripts, then these will also descend below the base-line. To
*     justify the bottom of the entire string (instead of just the
*     base-line), specify "M" instead of "B" in the justification string.
*     -  See function astFindEscape for details of the supported escape
*     sequences.
*/


/* Local Variables: */
   astDECLARE_GLOBALS
   char *a;
   char *lt;
   char cc;
   const char *lj;
   double ncol;
   double nfont;
   double nsize;
   double nstyle;
   double nwidth;
   float alpha_hi;
   float alpha_lo;
   float beta_lo;
   float beta_hi;
   float cy;
   float cx;
   float dy;
   float dx;
   float height;
   float hmx;
   float hmy;
   float ly;
   float lx;
   float rx;
   float rlen;
   float rise;
   float rxu;
   float ryu;
   float ry;
   float tdrop;
   float tybn[ 4 ];
   float txbn[ 4 ];
   float ulen;
   float uyu;
   float uxu;
   float uy;
   float ux;
   float width;
   float x0;
   float y0;
   int estype;
   int esval;
   int got_esc;
   int grfcap;
   int i;
   int nc;

/* Check the global error status, and that we have something to plot, and
   the reference position is good, and that the up vector is not zero. */
   if ( !astOK || !text || !text[ 0 ] ||  x == AST__BAD || y == AST__BAD ||
        ( upx == 0.0 && upy == 0.0 ) ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Initialise variables to avoid compiler warnings. */
   rx = 0.0f;
   ry = 0.0f;
   x0 = 0.0f;
   y0 = 0.0f;

/* Get an up vector which refers to the graphics coordinates in their correct
   senses (the supplied values are reversed if the corresponding axis is
   reversed). */
   ux = ( this->xrev ) ? -upx : upx;
   uy = ( this->yrev ) ? -upy : upy;

/* Find a vector which points from left to right along the text
   baseline, taking account of any difference in the scales of the x
   and y axes (is possible). This also scales the up vector so that it
   has a length equal to the height of normal text, and scales the right
   vector to have the same length (on the screen) as the up vector. */
   RightVector( this, &ux, &uy, &rx, &ry, method, class, status );

/* Create a unit right vector. */
   rlen = sqrt( rx*rx + ry*ry );
   rxu = rx/rlen;
   ryu = ry/rlen;

/* Create a unit up vector. */
   ulen = sqrt( ux*ux + uy*uy );
   uxu = ux/ulen;
   uyu = uy/ulen;

/* Some older GRF modules cannot plot strings with vertical justification
   of "M". Check the capabilities of the grf module, and, if necessary,
   modify the justification and the coords of the reference point to use
   "B" instead of "M". This call also returns us the coords at the left
   end of the baseline of normal text. */
   lx = x;
   ly = y;
   lj = JustMB( this, esc, text, &lx, &ly, upx, upy, just, uxu, uyu, rxu,
                ryu, &x0, &y0, method, class, status );

/* Initialise the horizontal and verical limits of the total bounding box. */
   alpha_lo = FLT_MAX;
   alpha_hi = -FLT_MAX;
   beta_lo = FLT_MAX;
   beta_hi = -FLT_MAX;

/* Tell the grf module whether or not to interpret escape sequences,and
   also note if the grf module is capable of interpreting escape
   sequences. */
   grfcap = GCap( this, GRF__ESC, esc, status );

/* Forget the horizontal position remembered by any "%h+" escape sequences
   from any previous string. */
   this->hmarkx = FLT_MAX;
   this->hmarky = FLT_MAX;

/* If escape sequences are being interpreted and the string contains some
   escape sequences, but the grf module cannot interpret escape sequences,
   split the supplied text up into sub-strings delimited by escape sequences
   and plot each sub-string individually, modifying the reference point and
   graphics attributes as indicated by the escape sequences. */
   if( esc && HasEscapes( text, status ) && !grfcap ) {

/* Take a copy of the supplied text so that we can temporarily terminate
   each sub-string by poking a null (0) character into it. */
      lt = (char *) astStore( NULL, (void *) text, strlen( text ) + 1 );

/* Indicate that the current baseline is at its normal height. */
      rise = 0.0;

/* Get the graphical attribute values for normal text. */
      GAttr( this, GRF__SIZE, AST__BAD, &nsize, GRF__TEXT, method, class, status );
      GAttr( this, GRF__WIDTH, AST__BAD, &nwidth, GRF__TEXT, method, class, status );
      GAttr( this, GRF__FONT, AST__BAD, &nfont, GRF__TEXT, method, class, status );
      GAttr( this, GRF__STYLE, AST__BAD, &nstyle, GRF__TEXT, method, class, status );
      GAttr( this, GRF__COLOUR, AST__BAD, &ncol, GRF__TEXT, method, class, status );

/* The "concatenation point" (cx,cy) is the point where the normal baseline
   crosses the left hand edge of the substring bounding box. Initialise
   this to the left edge of the first substring. */
      cx = x0;
      cy = y0;

/* Loop round the whole string, drawing each sub-string. */
      a = lt;
      while( *a && astOK ) {

/* Examine the start of the remaining string and note if it begins with
   an escape sequence. If so, the type and value of the escape sequnece
   is returned. In either case the number of characters to the next
   delimiter is returned. */
         got_esc = astFindEscape( a, &estype, &esval, &nc );

/* If the string starts with an escaped percent sign, modify things so that
   we can draw the percent sign with the normal text drawing code below. */
         if( got_esc && estype == GRF__ESPER ) {
            got_esc = 0;
            a++;
            nc = 1;
         }

/* If the string starts with any other escape sequence, modify the graphics
   attributes and concatenation point as required by the escape sequence. */
         if( got_esc ) {
            InterpEscape( this, estype, (double) esval, &cx, &cy, ux, uy,
                          rx, ry, lj, &rise, nsize, nstyle, nwidth, ncol,
                          nfont, method, class, status );

/* If the remaining string starts with normal text, draw it. */
         } else {

/* Temporarily terminate the sub-string which ends with the next escape
   sequence. */
            cc = a[ nc ];
            a[ nc ] = 0;

/* We now have to decide on the reference point for this sub-string. If
   the justification is "BL" then the reference point is just the current
   concatenation point. */
            if( lj[ 0 ] == 'B' && lj[ 1 ] == 'L' ) {
               lx = cx;
               ly = cy;

/* Otherwise, the reference point is offset from the concatenation point.
   It would be simpler to draw all substrings with "BL" justification but
   this causes problems with some grf modules (such as GAIA) which zoom
   the display by modifying the position of text strings without also
   modifying the size of text strings. Using the correct reference point
   for all sub-strings minimises the drift which occurs when such a grf
   modules zooms the display. */
            } else {

/* Find the width and height of this substring, and the distance between the
   bottom of the bounding box and the baseline (the drop). We do this
   by calling this function recursively, using "BL" justification to
   avoid infinite recursion. */

/* Forget the horizontal position remembered by any "%h+" escape sequences
   from any previous string. Save and re-instate the position of the
   horizontal mark since the call to DrawText may change it. */
               hmx = this->hmarkx;
               hmy = this->hmarky;

               DrawText( this, 0, esc, a, cx, cy, "BL", upx, upy, txbn, tybn,
                         &tdrop, method, class, status );

               this->hmarkx = hmx;
               this->hmarky = hmy;

               dx = txbn[ 0 ] - txbn[ 3 ];
               dy = tybn[ 0 ] - tybn[ 3 ];
               width = sqrt( dx*dx + dy*dy );

               dx = txbn[ 0 ] - txbn[ 1 ];
               dy = tybn[ 0 ] - tybn[ 1 ];
               height = sqrt( dx*dx + dy*dy );

/* First move right from the concatenation point by a fraction of the width
   of the substring (0.5 for "C" and 1.0 for "R"). */
               if( lj[ 1 ] == 'C' ) {
                  width *= 0.5;
               } else if( lj[ 1 ] != 'R' ) {
                  width = 0;
               }
               lx = cx + rxu*width;
               ly = cy + ryu*width;

/* Now move vertically by an amount which produes the requested vertical
   justification. */
               if( lj[ 0 ] == 'T' ) {
                  height -= tdrop;
                  lx += height*uxu;
                  ly += height*uyu;

               } else if( lj[ 0 ] == 'C' ) {
                  height = 0.5*height - tdrop;
                  lx += height*uxu;
                  ly += height*uyu;

               } else if( lj[ 0 ] == 'M' ) {
                  lx -= tdrop*uxu;
                  ly -= tdrop*uyu;
               }
            }

/* Draw it, and then find its real bounding box (i.e. using the correct
   reference position found above). */
            if( ink ) GText( this, a, lx, ly, lj, upx, upy, method, class, status );
            GTxExt( this, a, lx, ly, lj, upx, upy, txbn, tybn, method, class, status );

/* Re-instate the orignal value of the terminator character.*/
            a[ nc ] = cc;

/* Move the concatenation point to the right (i.e. in the direction of the text
   baseline) by an amount equal to the width of the bounding box. Also
   update the total bounding box limits.*/
            UpdateConcat( txbn, tybn, ux, uy, rx, ry, &cx, &cy,
                           x0, y0, &alpha_lo, &alpha_hi, &beta_lo, &beta_hi, status );
         }

/* Move on to the next character. */
         a += nc;
      }

/* Free resources. */
      lt = astFree( lt );

/* Reset all attributes to their normal values. */
      GAttr( this, GRF__SIZE, nsize, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__WIDTH, nwidth, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__COLOUR, ncol, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__FONT, nfont, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__STYLE, nstyle, NULL, GRF__TEXT, method, class, status );

/* If any escape sequences can be interpreted by the grf module, just pass
   the text string on to the grf module. */
   } else {
      if( ink ) GText( this, text, lx, ly, lj, upx, upy, method, class, status );
      GTxExt( this, text, lx, ly, lj, upx, upy, txbn, tybn, method, class, status );

/* The corners in the bounding box returned by GTxExt are in no
   particular order. But this function is contracted to return them
   in a specified order. So we use UpdateConcat to find the verical and
   horizontal limits of the box in a form which can be used to produce
   the correct order. UpdateConcat will also update the concatenation point,
   but that is irrelevant in this context. */
      UpdateConcat( txbn, tybn, ux, uy, rx, ry, &lx, &ly, x0, y0, &alpha_lo,
                     &alpha_hi, &beta_lo, &beta_hi, status );
   }

/* Return the total bounding box,in the order bottom left, topleft, top
   right, bottom right. */
   xbn[ 0 ] = x0 + alpha_lo*ux + beta_lo*rx;
   ybn[ 0 ] = y0 + alpha_lo*uy + beta_lo*ry;

   xbn[ 1 ] = x0 + alpha_hi*ux + beta_lo*rx;
   ybn[ 1 ] = y0 + alpha_hi*uy + beta_lo*ry;

   xbn[ 2 ] = x0 + alpha_hi*ux + beta_hi*rx;
   ybn[ 2 ] = y0 + alpha_hi*uy + beta_hi*ry;

   xbn[ 3 ] = x0 + alpha_lo*ux + beta_hi*rx;
   ybn[ 3 ] = y0 + alpha_lo*uy + beta_hi*ry;

/* Return the drop. */
   if( drop ) *drop =  -alpha_lo*ulen;

/* Free memory.*/
   lj = astFree( (void *) lj );

/* If OK, update the box containing all drawn graphics primitives. */
   if( ink && astOK && !Boxp_freeze ) {
      for( i = 0; i < 4; i++ ){
         Boxp_lbnd[ 0 ] = astMIN( xbn[ i ], Boxp_lbnd[ 0 ] );
         Boxp_ubnd[ 0 ] = astMAX( xbn[ i ], Boxp_ubnd[ 0 ] );
         Boxp_lbnd[ 1 ] = astMIN( ybn[ i ], Boxp_lbnd[ 1 ] );
         Boxp_ubnd[ 1 ] = astMAX( ybn[ i ], Boxp_ubnd[ 1 ] );
      }
   }
}

static void DrawTicks( AstPlot *this, TickInfo **grid, int drawgrid,
                       double *labelat, double *gap, const char *method,
                       const char *class, int *status ){
/*
*
*  Name:
*     DrawTicks

*  Purpose:
*     Draw tick marks for a 2-D annotated coordinate grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void DrawTicks( AstPlot *this, TickInfo **grid, int drawgrid,
*                     double *labelat, double *gap, const char *method,
*                     const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws major and minor tick marks. It uses a different
*     technique depending on whether the tick marks are to be put along the
*     edges of the plotting area, or along a curve through the middle of the
*     plotting area. The physical axis values at which to put tick marks
*     are supplied in parameter "grid".
*
*     If the ticks are placed on the edges of the plotting area, The
*     EdgeCrossings function is used to find all points along the edge which
*     have a physical axis value correspoinding to a tick value (there can in
*     general be more than one point on an edge with a given physical axis
*     value). Ticks are put at all such crossings.
*
*     If ticks are placed within the plotting area, then they are put
*     along a curve defined by the "other axis" values supplied in
*     parameter "labelat".

*  Parameters:
*     this
*        A pointer to the Plot.
*     grid
*        A pointer to an array of two TickInfo pointers (one for each axis),
*        each pointing to a TickInfo structure holding information about
*        tick marks on the axis. See function GridLines.
*     drawgrid
*        If non-zero, then a grid of curves has been drawn to mark the
*        major axis values.
*     labelat
*        A pointer to a 2 element array in holding the constant axis
*        values at which tick marks are to be put. Element 0 should hold
*        the axis 1 value at which tick marks for axis 0 are placed. Element
*        1 should hold the axis 0 value at which tick marks for axis
*        1 are placed. If ticks are to be placed round the edges of the
*        plotting zone instead of within the plotting zone, then values of
*        AST__BAD should be supplied.
*     gap
*        Pointer to array of two values holding the gap between major
*        tick marks on the two axes. This will be the difference between,
*        or the ratio of, adjacent tick mark values, depending on the
*        setting of the LogTicks attribute.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  This function assumes the current Frame of the Plot is 2
*     dimensional, and it should not be called if this is not the case.
*/

/* Local Variables: */
   AstFrame *frame;       /* Pointer to current Frame in Plot */
   AstMapping *mapping;   /* Pointer to graphics->physical Mapping */
   AstPointSet *pset1;    /* Pointer to PointSet holding physical coords. */
   AstPointSet *pset2;    /* Pointer to PointSet holding graphics coords. */
   AstPointSet *pset3;    /* Pointer to PointSet holding clipped graphics coords. */
   EdgeCrossingsStatics *ecstatics = NULL; /* For static data structure */
   TickInfo *info;        /* Pointer to the TickInfo for the current axis */
   double *ptr1[2];       /* Pointer to physical data */
   double **ptr2;         /* Pointer to graphics data */
   double **ptr3;         /* Pointer to clipped graphics data */
   double *a;             /* Pointer to next current axis value */
   double *b;             /* Pointer to next other axis value */
   double *value;         /* Current tick value */
   double *x;             /* Pointer to next X value */
   double *xc;            /* Pointer to next clipped X value */
   double *y;             /* Pointer to next Y value */
   double *yc;            /* Pointer to next clipped Y value */
   double a0;             /* Physical axis value at base of tick */
   double axmax;          /* Upper axis limit */
   double axmin;          /* Lower axis limit */
   double delta1;         /* Increment between minor ticks above major tick */
   double delta2;         /* Increment between minor ticks below major tick */
   double diff;           /* Difference between adjacent major ticks */
   double dl2;            /* Squared increment between points */
   double dl2_limit;      /* Minimum usable squared increment between points */
   double dl;             /* Increment between points */
   double dx;             /* X component of increment along tick mark */
   double dy;             /* Y component of increment along tick mark */
   double ex;             /* X component of increment between points */
   double ey;             /* Y component of increment between points */
   double lblat2;         /* Other axis value part way up each tick */
   double lblat;          /* Other axis value at base of each tick */
   double mindim;         /* Shortest dimension of plotting area */
   double minval;         /* Current axis value at next minor tick */
   double mjsign;         /* Sign of the major tick mark length */
   double mjtklen;        /* Length of major tick marks */
   double mnsign;         /* Sign of the minor tick mark length */
   double mntklen;        /* Length of minor tick marks */
   double ux;             /* X component of unit vector along tick mark */
   double uy;             /* Y component of unit vector along tick mark */
   double val;            /* Major axis value */
   double x0;             /* X at base of tick */
   double x1;             /* X at end of tick */
   double x2;             /* Clipped X at base of tick */
   double y0;             /* Y at base of tick */
   double y1;             /* Y at end of tick */
   double y2;             /* Clipped Y at base of tick */
   int *majflag;          /* Pointer to next major/minor flag */
   int *majflags;         /* Pointer to aray of major/minor flags */
   int axis;              /* Current axis index */
   int ed;                /* Doing a secondary edge? */
   int edge;              /* Index of edge being ticked */
   int first;             /* Is this the first tick to be drawn? */
   int gelid;             /* ID for next graphical element to be drawn */
   int i;                 /* Minor tick mark index */
   int logticks;          /* Are major tick marks logarithmically spaced? */
   int minhi;             /* Highest minor tick mark index */
   int minlo;             /* Lowest minor tick mark index */
   int nedge;             /* No. of edges to be ticked for each axis */
   int nel;               /* Actual number of tick marks to draw */
   int ntot;              /* Maximum number of tick marks */
   int tick;              /* Tick index */
   int lasttick;          /* Index of last major tick mark */

/* Check the global status. */
   if( !astOK ) return;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   a = NULL;
   delta1 = 0.0;
   delta2 = 0.0;
   lblat2 = 0.0;
   uy = 0.0;
   logticks = 0;

/* Get the minimum dimension of the plotting ares. */
   mindim = astMIN( this->xhi - this->xlo, this->yhi - this->ylo );

/* Information about the drawn tick marks is saved in the Plot structure.
   Reset this information now so that we are ready to store information
   about the new ticks that will be drawn by this function invocation. */
   SaveTick( this, -1, 0.0, 0.0, 0, status );

/* If ticks are to be put round the edges of the plotting area... */
/* ============================================================== */
   if( labelat[ 0 ] == AST__BAD || labelat[ 1 ] == AST__BAD ){

/* Store the number of edges to be ticked for each axis. */
      nedge = astGetTickAll( this )? 2 : 1;

/* Do each required edge. */
      for( ed = 0; ed < nedge; ed++ ){

/* Initialize the id value for graphical element being drawn. */
         gelid = AST__TICKS1_ID;

/* Do each axis. */
         for( axis = 0; axis < 2; axis++ ){

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
            astGrfAttrs( this, gelid, 1, GRF__LINE, method, class );

/* Store the length in graphics coordinates of major tick marks for this
   axis. Use a default of zero if a grid has been drawn. */
            if( astTestMajTickLen( this, axis ) || !drawgrid ){
               mjtklen = astGetMajTickLen( this, axis )*mindim;
            } else {
               mjtklen = 0.0;
            }

/* Store the length in graphics coordinates of minor tick marks. */
            mntklen = astGetMinTickLen( this, axis )*mindim;

/* Get the edge to be labelled with the axis values. Edge 0 is the left hand
   edge. Edge 1 is the top edge. Edge 2 is the right-hand edge. Edge 3 is
   the bottom edge. */
            edge = ( astGetEdge( this, axis ) + ed*2 ) % 4;
            if( edge < 0 ) edge = -edge;

/* Store a pointer to the structure containing information describing the
   positions of the major tick marks along this axis. */
            info = grid[ axis ];

/* Store a pointer to the axis value at the first major tick mark. */
            value = info->ticks;

/* Minor tick marks are drawn on both sides of each major tick mark. They
   are identified by an index number relative to major tick mark at zero.
   Store the indices of the first and last minor tick marks. */
            minlo = ( 1 - info->nminor )/2;
            minhi = info->nminor/2;

/* If major ticks are linear, store the difference between minor tick marks.
   This value will be the same for all major ticks. */
            logticks = astGetLogTicks( this, axis );
            if( !logticks ) {
               delta1 = gap[ axis ]/(double)info->nminor;
               delta2 = delta1;
            }

/* Loop round until all ticks have been done. */
            for( tick = 0; tick < info->nmajor; tick++ ){

/* Draw tick marks at all occurrences of the current major tick value on
   the selected edge of the plotting area. */
               Ticker( this, edge, axis, *value, gap, mjtklen,
                       1, ( ed == 0 ), &ecstatics, method, class, status );

/* If minor tick mark values were not supplied, calculate them as even
   intervals between the major tick values. */
               if( !info->minticks ) {

/* If major ticks are logarithmic, store the difference between minor tick
   marks. This value will be different for each major tick. Also, since
   the minor ticks are drawn on either side of the major tick, the minor
   tick spacing above the major tick will be different to that below the
   minor tick when using logarathmic ticks. "delta1" is the minor gap
   above the major value, and "delta2" is the minor gap below the major
   value. */
                  if( logticks ) {
                     delta1 = (*value) * ( gap[ axis ] - 1.0 )/
                                         (double)info->nminor;
                     delta2 = delta1 / gap[ axis ];
                  }

/* Extra minor tick marks are drawn below the first major tick mark and
   above the last major tick mark to fill in any gaps caused by axis
   limits being exceeded. */
                  if( tick == 0 ) {
                     minlo = 1 - info->nminor;
                  } if( tick == 1 ) {
                     minlo = ( 1 - info->nminor )/2;
                  } else if( tick == info->nmajor - 1 ) {
                     minhi = info->nminor - 1;
                  }

/* Store the axis value at the first minor tick mark. */
                  minval = *value + minlo*delta2;

/* Loop round all the minor tick marks, storing the physical coordinates
   defining the tick mark. */
                  for( i = minlo; i <= minhi; i++ ){

/* Draw tick marks at all occurrences of the current minor tick value on
   the selected edge of the plotting area. Do not do the minor tick mark
   with index zero, since this corresponds to the position of the major
   tick mark. */
                     if( i ) Ticker( this, edge, axis, minval, gap, mntklen,
                                     0, ( ed == 0 ), &ecstatics, method, class, status );

/* Get the axis value at the next minor tick mark. */
                     minval += ( i < 0 ) ? delta2 : delta1;
                  }
               }

/* Point to the next major tick value. */
               value++;

            }

/* If minor tick mark values have been supplied, used them. */
            if( info->minticks ) {
               value = info->minticks;
               for( tick = 0; tick < info->nminor; tick++, value++ ){
                  Ticker( this, edge, axis, *value, gap, mntklen, 0,
                          ( ed == 0 ), &ecstatics, method, class, status );
               }
            }

/* Re-establish the original graphical attributes. */
            astGrfAttrs( this, gelid, 0, GRF__LINE, method, class );

/* Set up the id for the next graphical element to be drawn. */
            gelid = AST__TICKS2_ID;
         }
      }

/* Free the static resources allocated within EdgeCrossings (called
   by Ticker). */
      (void) EdgeCrossings( NULL, 0, 0, 0.0, NULL, NULL, &ecstatics, method,
                            class, status );

/* If ticks are to put within the interior of the plotting area... */
/* ============================================================== */
   } else {

/* Get the mapping from base Frame (graphics coords) to current Frame
   (physical coords). */
      mapping = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Get the current Frame from the Plot. */
      frame = astGetFrame( this, AST__CURRENT );

/* Initialize the id value for graphical element being drawn. */
      gelid = AST__TICKS1_ID;

/* Do each axis. */
      for( axis = 0; axis < 2; axis++ ){

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
         astGrfAttrs( this, gelid, 1, GRF__LINE, method, class );

/* Store the length in graphics coordinates of major tick marks for this
   axis. Use a default of zero if a grid has been drawn. */
         if( astTestMajTickLen( this, axis ) || !drawgrid ){
            mjtklen = astGetMajTickLen( this, axis )*mindim;
         } else {
            mjtklen = 0.0;
         }

/* Store the length in graphics coordinates of minor tick marks. */
         mntklen = astGetMinTickLen( this, axis )*mindim;

/* Indicate that the tick mark lengths should not be negatated. */
         mjsign = 1.0;
         mnsign = 1.0;

/* Store the smallest squared distance in graphics coordinates which
   can reliably be used to determine the direction of a tick mark. */
         dl2_limit = 0.0001*mindim;
         dl2_limit *= dl2_limit;

/* Store a pointer to the structure containing information describing the
   positions of the major tick marks along this axis. */
         info = grid[ axis ];

/* Store a pointer to the axis value at the first major tick mark. */
         value = info->ticks;

/* Get the maximum number of tick marks to be drawn on this axis. */
         ntot = 0;
         ntot = info->nmajor;
         if( info->minticks ) {
            ntot += info->nmajor + info->nminor;
         } else {
            ntot += ( info->nmajor + 1 )*( info->nminor - 1 );
         }

/* Pass on to the next axis if no ticks are to be drawn. */
         if( ntot ) {

/* Allocate memory to hold the physical coordinates defining all the
   required tick marks. Each tick mark is defined by 2 points. */
            ptr1[ 0 ] = (double *) astMalloc( sizeof(double)*(size_t)(2*ntot) );
            ptr1[ 1 ] = (double *) astMalloc( sizeof(double)*(size_t)(2*ntot) );

/* Allocate memory to hold a set of flags indicating whether each tick
   mark is minor or major. */
            majflags = (int *) astMalloc( sizeof(int)*(size_t)ntot );

/* Check the pointers can be used. */
            if( astOK ){

/* If the tick values have been supplied using astSetTickValues, just
   copy them into the above arrays. */
               if( info->minticks ) {

                  a = ptr1[ axis ];
                  b = ptr1[ 1 - axis ];
                  majflag = majflags;

                  for( tick = 0; tick <= info->nmajor; tick++ ){

                     val =  info->ticks[ tick ];
                     if( logticks ) {
                        diff = val * ( gap[ axis ] - 1.0 );
                        lblat2 = labelat[ axis ] + 0.2*diff;
                     } else {
                        lblat2 = labelat[ axis ] + 0.2*gap[ 1 - axis ];
                     }

                     *(a++) = val;
                     *(b++) = labelat[ axis ];
                     *(a++) = val;
                     *(b++) = lblat2;
                     *(majflag++) = 1;
                  }

                  for( tick = 0; tick <= info->nminor; tick++ ){

                     val =  info->minticks[ tick ];
                     if( logticks ) {
                        diff = val * ( gap[ axis ] - 1.0 );
                        lblat2 = labelat[ axis ] + 0.2*diff;
                     } else {
                        lblat2 = labelat[ axis ] + 0.2*gap[ 1 - axis ];
                     }

                     *(a++) = val;
                     *(b++) = labelat[ axis ];
                     *(a++) = val;
                     *(b++) = lblat2;
                     *(majflag++) = 0;
                  }

/* If the tick values were not supplied using astSetTickValues, then we
   need to calculate the minor tick positions explicitly. */
               } else {

/* Store pointers to the next point on each axis. "a" always refers to the
   current axis. Also store the value on the other axis at which the tick
   marks starts, and another value on the other axis which is used to
   defined the tick mark directions. */
                  a = ptr1[ axis ];
                  b = ptr1[ 1 - axis ];
                  majflag = majflags;
                  lblat = labelat[ axis ];

/* Store another value on the other axis which is used to defined the tick
   mark directions, and the difference between minor tick marks. For
   linearly spaced tick marks these values will be the same for all major
   ticks. Minor ticks are always drawn above the correponding major
   value (i.e. minlo == 1 ) and so we do not need to set delta2. */
                  logticks = astGetLogTicks( this, axis );
                  if( !logticks ) {
                     lblat2 = labelat[ axis ] + 0.2*gap[ 1 - axis ];
                     delta1 = gap[ axis  ]/(double)info->nminor;
                  }

/* Store the indices of the first and last minor tick marks, relative to
   a major tick mark. */
                  minlo = 1;
                  minhi = info->nminor - 1;

/* Get the axis limits. */
                  axmin = astGetBottom( frame, axis );
                  axmax = astGetTop( frame, axis );

/* Loop round until all ticks have been done. We include a hypothetical tick
   at index -1 (i.e. one gap below the first listed tick value) in order
   to get minor tick marks below the first major tick. But the
   hypothetical major tick value is not included in the list of major tick
   values to draw. */
                  lasttick = info->nmajor - 1;
                  for( tick = -1; tick <= lasttick; tick++ ){

/* Get the major tick value. */
                     if( tick == -1 ) {
                        if( !logticks ) {
                           val = (*value) - gap[ axis ];
                        }else {
                           val = (*value)/gap[ axis ];
                        }
                     } else {
                        val = *(value++);
                     }

/* Now find the value on the other axis which is used to defined the tick
   mark directions, and the difference between minor tick marks, in the
   case of logarithmically spaced tick marks. These values will be
   different for every major tick. Minor ticks are always drawn above the
   correponding major value (i.e. minlo == 1 ) and so we do not need to set
   delta2. */
                     if( logticks ) {
                        diff = val * ( gap[ axis ] - 1.0 );
                        lblat2 = labelat[ axis ] + 0.2*diff;
                        delta1 = diff / (double)info->nminor;
                     }

/* If major tick marks are required, store the physical coordinates at the
   start of the major tick mark, and at a point a little way up the major
   tick mark. */
                     if( tick > -1 ){
                        *(a++) = val;
                        *(b++) = lblat;
                        *(a++) = val;
                        *(b++) = lblat2;
                        *(majflag++) = 1;
                     }

/* Store the points defining the minor tick marks on either side of
   this major tick mark. First store the axis value at the first minor
   tick mark. */
                     minval = val + minlo*delta1;

/* Loop round all the minor tick marks, storing the physical coordinates
   defining the tick mark. */
                     for( i = minlo; i <= minhi; i++ ){

/* Do not do the minor tick mark with index zero, since this corresponds
   to the position of the major tick mark. Do not do any minor ticks that
   are outside the axis range. */
                        if( i && minval >= axmin && minval <= axmax ){
                           *(a++) = minval;
                           *(b++) = lblat;
                           *(a++) = minval;
                           *(b++) = lblat2;
                           *(majflag++) = 0;
                        }

/* Get the axis value at the next minor tick mark. */
                        minval += delta1;
                     }
                  }
               }
            }

/* Adjust the size of the arrays to exclude any unused space. */
            nel = a - ptr1[axis];
            ptr1[axis] = (double *) astRealloc( (void *) ptr1[axis],
                                                sizeof(double)*nel );
            ptr1[1-axis] = (double *) astRealloc( (void *) ptr1[1-axis],
                                                  sizeof(double)*nel );

/* Create a pointset holding these coordinates. */
            pset1 = astPointSet( nel, 2, "", status );
            astSetPoints( pset1, ptr1 );

/* Transform these physical coordinates into graphics coordinates, without
   doing any clipping (this is so that tick marks are still drawn even if
   they extend into the area containing clipped physical coordinates). */
            pset2 = astTransform( mapping, pset1, 0, NULL );
            ptr2 = astGetPoints( pset2 );

/* Transform them again this time with clipping. */
            pset3 = Trans( this, NULL, mapping, pset1, 0, NULL, 0, method, class, status );
            ptr3 = astGetPoints( pset3 );

/* Check the pointers can be used.*/
            if( astOK ){

/* Store pointers to the next point on each axis. */
               a = ptr1[ axis ];

               x = ptr2[ 0 ];
               y = ptr2[ 1 ];

               xc = ptr3[ 0 ];
               yc = ptr3[ 1 ];

               majflag = majflags;

/* Loop round all ticks (major and minor). */
               ux = AST__BAD;
               first = 1;
               for( tick = 0; tick < nel/2; tick++ ){

/* Store the physical axis value at the base of the tick mark (skip over
   the physical axis value at the point up the tick mark). */
                  a0 = *(a++);
                  a++;

/* Store the x and y coordinates at the base of the tick mark. */
                  x0 = *(x++);
                  y0 = *(y++);

/* Store the x and y coordinates at a point up the tick mark. */
                  x1 = *(x++);
                  y1 = *(y++);

/* Store the clipped x and y coordinates at the base of the tick mark. */
                  x2 = *(xc++);
                  y2 = *(yc++);

/* Skip over the clipped x and y coordinates at the point up the tick mark. */
                  xc++;
                  yc++;

/* Check they are all valid, and that the start of the tick mark is within
   the plotting area. */
                  if( x0 != AST__BAD && y0 != AST__BAD &&
                      x1 != AST__BAD && y1 != AST__BAD &&
                      x2 != AST__BAD && y2 != AST__BAD &&
                      x0 <= this->xhi && x0 >= this->xlo &&
                      y0 <= this->yhi && y0 >= this->ylo ){

/* Get the increments in X and Y beyween the two points, and the squared
   distance between the two points. */
                     dx = x1 - x0;
                     dy = y1 - y0;
                     dl2 = dx*dx + dy*dy;

/* Check the two points are not co-incident. */
                     if( dl2 > dl2_limit ){

/* Store the distance between the two points. */
                        dl = sqrt( dl2 );

/* If this is the first tick to be drawn on this axis, decide which
   direction to draw the tick mark so that they will appear on the right
   hand side of the axis as seen by someone moving along the axis in the
   positive direction (the numerical labels are also drawn on the same
   side). */
                        if( first ){
                           first = 0;

/* If the next tick mark is not defined, make an arbitrary decision by
   leaving the sign of the tick mark length unchanged. */
                           if( tick + 1 < nel/2 &&
                               *x != AST__BAD && *y != AST__BAD &&
                               a0 != AST__BAD && *a != AST__BAD ){

/* Form the vector joining this tick mark to the next. */
                               ex = *x - x0;
                               ey = *y - y0;

/* Ensure this vector is in the positive direction of the axis. */
                               if( *a < a0 ) {
                                  ex = -ex;
                                  ey = -ey;
                               }

/* If a positive tick mark length would put the marks on the wrong side,
   negate the tick mark length. */
                               if( ex*dy > ey*dx ){
                                  mjsign = -1.0;
                                  mnsign = -1.0;
                               }
                           }
                        }

/* Store the unit vector in the direction of the tick mark. This is used
   as the default vector for the next tick mark if the direction of the
   next tick mark is indeterminate. */
                        ux = dx/dl;
                        uy = dy/dl;
                     }

/* Only draw this tickmark if its direction is known. */
                     if( ux != AST__BAD ) {

/* Get the position of the end of the tick mark. The length of the tick
   mark depends on whether it is a major or minor tick mark. */
                        if( *majflag ){
                           x1 = x0 + mjsign*mjtklen*ux;
                           y1 = y0 + mjsign*mjtklen*uy;
                        } else {
                           x1 = x0 + mnsign*mntklen*ux;
                           y1 = y0 + mnsign*mntklen*uy;
                        }

/* Save and draw the tick mark. */
                        SaveTick( this, axis, x0, y0, *majflag, status );
                        if( x0 != x1 || y0 != y1 ) {
                           Bpoly( this, (float) x0, (float) y0, status );
                           Apoly( this, (float) x1, (float) y1, status );
                           Opoly( this, status );
                        }
                     }
                  }

/* Point to the next major/minor flag. */
                  majflag++;
               }
            }

/* Free the memory holding the physical coordinates. */
            ptr1[ 0 ] = (double *) astFree( ( void *) ptr1[ 0 ] );
            ptr1[ 1 ] = (double *) astFree( ( void *) ptr1[ 1 ] );
            majflags = (int *) astFree( (void *) majflags );

/* Annul the PointSets. */
            pset1 = astAnnul( pset1 );
            pset2 = astAnnul( pset2 );
            pset3 = astAnnul( pset3 );
         }

/* Re-establish the original graphical attributes. */
         astGrfAttrs( this, gelid, 0, GRF__LINE, method, class );

/* Set up the id for the next graphical element to be drawn. */
         gelid = AST__TICKS2_ID;
      }

/* Annul the pointers to the Mapping and Frame. */
      mapping = astAnnul( mapping );
      frame = astAnnul( frame );

   }

/* Return. */
   return;

}

static void EBuf( AstPlot *this, int *status ) {
/*
*++
*  Name:
c     astEBuf
f     AST_EBUF

*  Purpose:
*     End the current graphical buffering context.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     void astEBuf( AstPlot *this )
f     CALL AST_EBUF( THIS STATUS )

*  Class Membership:
*     Plot member function.

*  Description:
c     This function
f     This routine
*     ends the current graphics buffering context. It should match a
*     corresponding call to the
c     astBBuf function.
f     AST_EBUF routine.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - The nature of the buffering is determined by the underlying
*     graphics system (as defined by the current grf module). Each call
c     to this function
f     to this routine
*     simply invokes the astGEBuf function in the grf module.

*--
*/

/* Check the global error status. */
   if ( !astOK ) return;

/* Invoke the active GRF EBuf function. */
   GEBuf( this, "astEBuf", astGetClass( this ), status );
}

static int EdgeLabels( AstPlot *this, int ink, TickInfo **grid,
                       AstPlotCurveData **cdata, int force, const char *method,
                       const char *class, int *status ){
/*
*
*  Name:
*     EdgeLabels

*  Purpose:
*     Attempts to display labels for the major tick values around the edges
*     of the plotting area.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int EdgeLabels( AstPlot *this, int ink, TickInfo **grid,
*                     AstPlotCurveData **cdata, int force, const char *method,
*                     const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function determines how many major tick value labels could be
*     placed on the specified edges of the plotting area, and then if
*     requested, and if sufficient such labels are found (more than 3 on
*     each axis), they are drawn. To place a label on an edge, the curve
*     defining the major tick value must cross the edge at a reasonably
*     angle (at least 3 degrees). Labels are not drawn which would overlap
*     other, previously drawn, labels. A flag is returned indicating if
*     edge labels were (or could be) drawn.

*  Parameters:
*     this
*        A pointer to the Plot.
*     ink
*        If zero, then no labels are drawn, but the decision whether or
*        not to draw them is still made and indicated in the returned function
*        value.
*     grid
*        A pointer to an array of two TickInfo pointers (one for each axis),
*        each pointing to a TickInfo structure holding information about
*        tick marks on the axis. See function GridLines.
*     cdata
*        A pointer to an array of two AstPlotCurveData pointers (one for each axis),
*        each pointing to an array of AstPlotCurveData structure (one for each
*        major tick value on the axis), holding information about breaks
*        in the curves drawn to mark the major tick values. See function
*        DrawGrid.
*     force
*        If non-zero, then an attempt is made to draw edge labels even if
*        it looks like insufficient edge labels can be produced.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     If edge labels were drawn, 1 is returned. Otherwise 0 is returned.

*  Notes:
*     -  Zero is returned if an error has already occurred.
*/


/* Local Variables: */
   AstFrame *frame;       /* Pointer to current Frame */
   AstPlotCurveData *cdt; /* Pointer to the AstPlotCurveData for the next tick */
   LabelList *labellist;  /* Pointer to a ingle list of labels to be plotted */
   LabelList *ll;         /* Pointer to next label to be plotted */
   LabelList *llist[2];   /* Pointers to both lists of labels to be plotted */
   TickInfo *info;        /* Pointer to the TickInfo for the current axis */
   const char *just[ 2 ]; /* Justification string */
   const char *text;      /* Pointer to label text */
   double edgeval;        /* Axis value at the labelled edge */
   double mindim;         /* Minimum dimension of the plotting area */
   double tol;            /* Max. distance between a break and the edge */
   double txtgap;         /* Absolute gap between labels and edges */
   float *box;            /* Pointer to array of label bounding boxes */
   float *vxbrk;          /* X component of unit vector at current break */
   float *vybrk;          /* Y component of unit vector at current break */
   float *xbrk;           /* X coord. of current break */
   float *ybrk;           /* Y coord. of current break */
   float xref;            /* X coordinate at label's reference position */
   float yref;            /* Y coordinate at label's reference position */
   int axis;              /* Current axis index */
   int brk;               /* Current break index */
   int edge;              /* The edge to be labelled */
   int edgeax;            /* Index of axis parallel to the labelled edge */
   int edgelabs;          /* Can edge labels be produced? */
   int esc;               /* INterpret escape sequences? */
   int gelid;             /* ID for next graphical element to be drawn */
   int ii;                /* Index into existing labels */
   int maxlab;            /* Number of distinct edge labels */
   int medge[2];          /* No. of distinct edge labels for each axis */
   int naxlab;            /* Number of edge labels */
   int near;              /* Draw a label on the near edge? */
   int nedge[2];          /* No. of edge labels for each axis */
   int ok;                /* Can the current tick mark be labelled on the edge? */
   int labfound;          /* Label value has already been used? */
   int tick;              /* Tick index */
   int upright;           /* Draw all labels upright? */

/* Check the global status. */
   if( !astOK ) return 0;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   xref = 0.0;
   yref = 0.0;

/* See if escape sequences in text strings are to be interpreted. */
   esc = astGetEscape( this );

/* Initialise the returned flag to indicate that edge labels cannot be
   produced. */
   edgelabs = 0;

/* Get the minimum dimension of the plotting ares. */
   mindim = astMIN( this->xhi - this->xlo, this->yhi - this->ylo );

/* Set up the tolerance for curve breaks occuring on an edge of
   the plotting zone. */
   tol = 0.005*mindim;

/* First, we get a list of all the labels which can be produced on each
   axis. The list includes the labels reference position in graphics
   coordinates, and the index of the major tick value which it
   represents. We do not yet know whether enough of the grid lines cross
   the required edge to make it feasable to use edge labelling, so we do
   not yet draw the labels.
   =====================================================================*/

/* Initialise pointers to arrays of structures holding information
   about the labels which can be draw round the edge for both axes. */
   llist[ 0 ] = NULL;
   llist[ 1 ] = NULL;

/* Indicate that no labels can yet be drawn on either axis. */
   nedge[ 0 ] = 0;
   nedge[ 1 ] = 0;

/* The "nedge" array counts the number of labels on each edge. But some
   of these labels may be for the same tick mark (if the tick mark curve has
   more than 1 intersection with the edge). The "medge" array counts the
   number of *distinct* tick mark labels (i.e. the number of tick mark
   values which have 1 or more interesections with the edge). */
   medge[ 0 ] = 0;
   medge[ 1 ] = 0;

/* For each axis, identify the the usable edge labels. */
   for( axis = 0; axis < 2; axis++ ){

/* See if labels for this axis are to be drawn upright. */
      if( astTestLabelUp( this, axis ) ) {
         upright = astGetLabelUp( this, axis );
      } else {
         upright = 1;
      }

/* Store the required gap between the label text and the axis. */
      txtgap = astGetNumLabGap( this, axis )*mindim;

/* Get the edge to be labelled with the axis values. Edge 0 is the left hand
   edge. Edge 1 is the top edge. Edge 2 is the right-hand edge. Edge 3 is
   the bottom edge. */
      edge = astGetEdge( this, axis ) % 4;
      if( edge < 0 ) edge = -edge;

/* If edge labels for the current axis are to go on the left hand edge of
   the plotting area... */
      if( edge == 0 ){

/* Choose the justification based on the sign of the text gap. */
         if( !upright ) {
            just[ axis ] = "BC";
         } else if( txtgap > 0.0 ){
            just[ axis ] = "CR";
         } else if( txtgap < 0.0 ){
            just[ axis ] = "CL";
         } else {
            just[ axis ] = "CC";
         }

/* Store the constant X axis value at the edge being labelled. Also store
   the X value to use for the reference position for all labels. Take into
   account whether or not the X axis is displayed reversed (i.e. with high
   X values at the left hand side of the screen ). */
         if( !this->xrev ){
            edgeval = this->xlo;
            xref = (float)( edgeval - txtgap );
         } else {
            edgeval = this->xhi;
            xref = (float)( edgeval + txtgap );
         }

/* Indicate that the "edgeval" value refers to axis 1 (the X axis). */
         edgeax = 1;

/* Do the same if the labels are to go on the top edge. */
      } else if( edge == 1 ){
         if( txtgap > 0.0 ){
            just[ axis ] = "BC";
         } else if( txtgap < 0.0 ){
            just[ axis ] = "TC";
         } else {
            just[ axis ] = "CC";
         }

         if( !this->yrev ){
            edgeval = this->yhi;
            yref = (float)( edgeval + txtgap );
         } else {
            edgeval = this->ylo;
            yref = (float)( edgeval - txtgap );
         }

         edgeax = 0;

/* Do the same if the labels are to go on the right-hand edge. */
      } else if( edge == 2 ){

         if( !upright ) {
            just[ axis ] = "BC";
         } else if( txtgap > 0.0 ){
            just[ axis ] = "CL";
         } else if( txtgap < 0.0 ){
            just[ axis ] = "CR";
         } else {
            just[ axis ] = "CC";
         }

         if( !this->xrev ){
            edgeval = this->xhi;
            xref = (float)( edgeval + txtgap );
         } else {
            edgeval = this->xlo;
            xref = (float)( edgeval - txtgap );
         }

         edgeax = 1;

/* Do the same if the labels are to go on the bottom edge. */
      } else {
         if( txtgap > 0.0 ){
            just[ axis ] = "TC";
         } else if( txtgap < 0.0 ){
            just[ axis ] = "BC";
         } else {
            just[ axis ] = "CC";
         }

         if( !this->yrev ){
            edgeval = this->ylo;
            yref = (float)( edgeval - txtgap );
         } else {
            edgeval = this->yhi;
            yref = (float)( edgeval + txtgap );
         }

         edgeax = 0;

      }

/* Get a pointer to the structure containing information describing the
   positions of the major tick marks along this axis. */
      info = grid[ axis ];

/* Get a pointer to the structure containing information describing the
   breaks in the curve which is parallel to the other axis and passes
   through the first major tick mark. */
      cdt = cdata[ axis ];

/* Initialise the pointer to the list of text strings to be drawn. */
      labellist = NULL;

/* Initialise the number of labels which can be placed on the near edge of
   the plotting zone (some of which may be the same). */
      naxlab = 0;

/* Initialise the number of distinct labelled tick mark values. */
      maxlab = 0;

/* Loop round each of the major tick marks on the current axis. */
      for( tick = 0; cdt && info && tick < info->nmajor; tick++ ){

/* Store pointers to the values giving the position and unit direction
   vector of the curve at the first break. */
         xbrk = cdt->xbrk;
         ybrk = cdt->ybrk;
         vxbrk = cdt->vxbrk;
         vybrk = cdt->vybrk;

/* Loop round each of the breaks in the curve which passes through the
   current major tick mark, and is parallel to the other axis. */
         ok = 0;
         for( brk = 0; brk < cdt->nbrk; brk++ ){

/* A label can be produced on the near edge of the plotting zone if the
   current break occurs on, or close to, the edge, and the curve is not
   nearly parallel to the axis (limit is 5 degs). */
            near = ( ( edgeax == 0 &&
                       fabs( (double) *ybrk - edgeval ) < tol &&
                       fabs( (double) *vybrk ) > 0.09 ) ||
                     ( edgeax == 1 &&
                       fabs( (double) *xbrk - edgeval ) < tol &&
                       fabs( (double) *vxbrk ) > 0.09 ) );

/* Get the label text. */
            if( info->labels ) {
               text = (info->labels)[ tick ];
            } else {
               text = NULL;
            }

/* If a label can be produced, record the information needed to draw the
   label. */
            if( near && text ){

               labellist = (LabelList *) astGrow( (void *) labellist, naxlab + 1, sizeof(LabelList) );
               if ( !astOK ) break;

               if( edgeax == 0 ){
                  (labellist + naxlab)->index = (double) *xbrk;
                  (labellist + naxlab)->x = (double) *xbrk;
                  (labellist + naxlab)->y = (double) yref;
               } else {
                  (labellist + naxlab)->index = (double) *ybrk;
                  (labellist + naxlab)->x = (double) xref;
                  (labellist + naxlab)->y = (double) *ybrk;
               }

               (labellist + naxlab)->text = (char *) astStore( NULL, (void *) text, strlen(text) + 1 );
               (labellist + naxlab)->just = (char *) astStore( NULL, (void *) just[ axis ], strlen(just[ axis ]) + 1 );

/* The up vector depends on which edge is being labelled and whether all
   labels are being drawn upright or not. */
               if( edge == 1 || edge == 3 || upright ) {
                  (labellist + naxlab)->upx = 0.0;
                  (labellist + naxlab)->upy = 1.0;
               } else if( edge == 0 ) {
                  (labellist + naxlab)->upx = -1.0;
                  (labellist + naxlab)->upy = 0.0;
               } else {
                  (labellist + naxlab)->upx = 1.0;
                  (labellist + naxlab)->upy = 0.0;
               }

               (labellist + naxlab)->val = (info->ticks)[ tick ];
               naxlab++;

/* If this label has not already been included in the label list, indicate
   that we have found another usable label. */
               labfound = 0;
               for( ii = 0; ii < naxlab-1; ii++ ) {
                  if( fabs( (info->ticks)[ tick ] -
                            (labellist + ii)->val ) < 0.2*info->gap ) {
                     labfound = 1;
                     break;
                  }
               }
               if( !labfound ) ok = 1;

            }

/* Increment the pointers to the values giving the position and unit direction
   vector of the next break. */
            xbrk++;
            ybrk++;
            vxbrk++;
            vybrk++;

         }

/* If an error has occurred, break out of the loop. */
         if( !astOK ) break;

/* If one or more labels could be produced for this tick mark value,
   increment the number of labeled tick marks found. */
         if( ok ) maxlab++;

/* Get a pointer to the curve through the next major tick mark. */
         cdt++;

      }

/* If an error has occurred, break out of the loop. */
      if( !astOK ) break;

/* Store the number of labels for this axis, and the pointer to the
   drawable labels. */
      nedge[ axis ] = naxlab;
      medge[ axis ] = maxlab;
      llist[ axis ] = labellist;
   }

/* We now know how many labels would be produced on each axis if edge
   labelling were to be used. We also know what those labelled values are,
   and where the labels would be drawn. We now take the decision as to
   whether there are enough of these labels to make edge labelling
   feasable. If so, we carry on and draw the labels. There need to be
   at least 3 labels on each axis for linear tick spacing and 2 for log
   tick spacing (or a non-zero value supplied for "force")...
   ================================================================= */
   if( astOK && ( ( medge[ 0 ] > ( astGetLogTicks( this, 0 ) ? 1 : 2 ) &&
                    medge[ 1 ] > ( astGetLogTicks( this, 1 ) ? 1 : 2 ) )
       || force ) ) {

/* Set the returned flag to indicate that edge labelling is being used. */
      edgelabs = 1;

/* Initialise the pointer to the memory holding the bounding boxes for
   all labels (used by function Overlap). */
      box = NULL;

/* Get a pointer to the current Frame in the Plot. */
      frame = astGetFrame( this, AST__CURRENT );

/* Initialize the id value for graphical element being drawn. */
      gelid = AST__NUMLAB1_ID;

/* If required, draw the labels for each axis in turn. */
      for( axis = 0; axis < 2 && ink; axis++ ){

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
         astGrfAttrs( this, gelid, 1, GRF__TEXT, method, class );

/* Plot them. */
         info = grid[ axis ];
         PlotLabels( this, esc, frame, axis, llist[ axis ], info->fmt,
                     nedge[ axis ], &box, method, class, status );

/* Re-establish the original graphical attributes. */
         astGrfAttrs( this, gelid, 0, GRF__TEXT, method, class );

/* Set up the id for the next graphical element to be drawn. */
         gelid = AST__NUMLAB2_ID;

      }

/* Free the memory used to hold the bounding boxes. */
      box = (float *) astFree( (void *) box );

/* Annul the pointer to the Frame. */
      frame = astAnnul( frame );
   }

/* Free the memory used to store the label information. */
   for( axis = 0; axis < 2; axis++ ){
      ll = llist[ axis ];
      if( ll ) {
         for( tick = 0; tick < nedge[ axis ]; tick ++ ) {
            ll->text = (char *) astFree( (void *) ll->text );
            ll->just = (char *) astFree( (void *) ll->just );
            ll++;
         }
         llist[ axis ] = (LabelList *) astFree( (void *) llist[ axis ] );
      }
   }

/* Return the flag indicating if edge labels were produced. */
   return edgelabs;

}

static int EdgeCrossings( AstPlot *this, int edge, int axis, double axval,
                          double *gap, double **cross,
                          EdgeCrossingsStatics **pstatics, const char *method,
                          const char *class, int *status ){
/*
*
*  Name:
*     EdgeCrossings

*  Purpose:
*     Find all occurrences of a given physical axis value on an edge of the
*     plotting area.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int EdgeCrossings( AstPlot *this, int edge, int axis, double axval,
*                        double *gap, double **cross,
*                        EdgeCrossingsStatics **pstatics,
*                        const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function finds all occurences of a given physical axis value
*     along a specified edge of the plotting area. Firstly, a set of evenly
*     spaced points ("edge samples") are placed along the edge and the
*     corresponding physical coordinates are found. These physical coordinates
*     are then offset slightly from their original positions in the direction
*     of the "other" axis (i.e. index [ 1 - axis ] ), and transformed back
*     into graphics coordinates. These coordinates give the tangent vector
*     at each of the edge samples.
*
*     To find the crossings, the supplied axis value is compared with the axis
*     value at each sample in turn, starting from one end of the edge and
*     working through to the other end. When a crossing is found, linear
*     interpolation is used between the two adjacent edge samples to find a
*     more accurate estimate of the crossing. The vector at the crossing
*     is also estimated by linear interpolation between the vectors at the two
*     adjacent samples.
*
*     This basic algorithm fails if there is a discontinuity in the axis
*     values along the edge. For instance, if the edge covers a range of
*     Right Ascension from 23h to 1h, there will be a discontinuity at 0h
*     at which the RA values suddenly jump from 2*PI to zero. This jump
*     encompasses all normalised RA values and so every axis value would be
*     given a crossing at this point. To avoid this, a bad sample is
*     interposed between the two samples on either side of the
*     discontinuity. This prevents any crossings from being placed at the
*     discontinuity.
*
*     There is a second problem related to discontinuities. If the supplied
*     axis value is zero (using the above RA example again), then no
*     crossings will be found, not only because of the extra bad sample,
*     but also because the samples will not quite cover the range of axis
*     values covered by the discontinuity because of the discrete nature
*     of the samples). To get round this, the sections on either side
*     of the discontinity are extended by a single sample. These extra
*     samples are assumed to be conincident with the neighbouring sample,
*     except that the value for the searched axis is modified to be a
*     linear extension from the neighbouring samples.


*  Parameters:
*     this
*        A pointer to the Plot. Supply a NULL pointer to release resources.
*     edge
*        The edge of the plotting area to be used. Edge 0 is the left hand
*        edge. Edge 1 is the top edge. Edge 2 is the right-hand edge. Edge 3
*        is the bottom edge.
*     axis
*        The index of the axis to which "axval" refers.
*     axval
*        The physical axis value to be searched for.
*     gap
*        Pointer to array of two values holding the gap between major
*        tick marks on the two axes.
*     cross
*        A pointer to the location at which to return a pointer to an
*        array of doubles holding the crossing information. Each crossing
*        is described by 4 doubles. The first pair are the graphiucs (x,y)
*        coordinates of the point on the edge at which the crossing occurs.
*        The second pair represents a unit vector in graphics coordinates
*        which is tangential to the curve of constant axis value at the
*        crossing. The memory allocated within this function to hold this
*        data should be freed using astFree when no longer needed. If no
*        crossings are found a NULL pointer is returned.
*     pstatics
*        Address of a pointer to a structure holding values for variables
*        which were statically defined within this function prior to the
*        thread-safe version of AST. If the pointer is supplied as NULL,
*        then a new structure is allocated and initialised. Any supplied
*        structure is freed if a NULL pointer is supplied for "this".
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Return Value:
*     The number of crossings found.

*  Notes:
*     -  This function allocates static resource on the first invocation
*     which should be freed when no more calls are to be made, by making a
*     final call with a NULL pointer supplied for "this". All other parameters
*     are then ignored.
*     -  The static resources are re-initialised each time "edge" or
*     "axis" changes, and so the calling function should be structure in
*     order to minimise the number of times these parameter values change.
*     -  If an error has already occurred, or if this function should
*     fail for any reason, zero is returned, and a NULL pointer is stored at
*     "cross".

*/

/* Local Variables: */
   EdgeCrossingsStatics *statics; /* Structure holding static data */
   AstMapping *mapping;       /* Pointer to graphics->physical mapping */
   AstPointSet *pset1a;       /* Physical cooords at offset edge samples */
   AstPointSet *pset2a;       /* Physical cooords at offset edge samples */
   AstPointSet *pset3;        /* Physical cooords at offset edge samples */
   AstPointSet *pset4a;       /* Physical cooords at offset edge samples */
   double **ptr1a;            /* Pointer to physical coord. data */
   double **ptr2a;            /* Pointer to physical coord. data */
   double **ptr3;             /* Pointer to physical coord. data */
   double **ptr4a;            /* Pointer to physical coord. data */
   double *data;              /* Pointer to next item of crossing information */
   double *p1;                /* Pointer to graphics axis with constant value */
   double *p1a;               /* Pointer to graphics axis with constant value */
   double *p2;                /* Pointer to graphics axis with varying value */
   double *p2a;               /* Pointer to graphics axis with varying value */
   double *q1;                /* Pointer to physical axis being searched */
   double *q1a;               /* Pointer to physical axis being searched */
   double *q2;                /* Pointer to other physical axis */
   double *q2a;               /* Pointer to other physical axis */
   double *v1;                /* Pointer to vector component on axis 0 */
   double *v2;                /* Pointer to vector component on axis 1 */
   double *v1a;               /* Pointer to vector component on axis 0 */
   double *v2a;               /* Pointer to vector component on axis 1 */
   double dd;                 /* The gap between edge samples */
   double diff;               /* Squared differences between adjacent edge samples */
   double dl2;                /* Squared vector length */
   double dl;                 /* Vector length */
   double dx;                 /* Vector X component */
   double dy;                 /* Vector Y component */
   double f;                  /* Weight for the current edge sample */
   double offset;             /* Physical offset */
   double pp2;                /* Varying graphics axis value at previous sample */
   double pq1;                /* Required physical axis value at previous sample */
   double pv1;                /* Previous vector component on axis 0 */
   double pv2;                /* Previous vector component on axis 1 */
   double sum;                /* Sum of squared differences between adjacent edge samples */
   double value;              /* The current graphics axis value */
   double vx;                 /* Vector component on axis 0 at crossing */
   double vy;                 /* Vector component on axis 1 at crossing */
   double z;                  /* Varying graphics axis value at crossing */
   int i;                     /* Edge sample index */
   int iter;                  /* Iteration index */
   int larger;                /* Is current axis value larger than target? */
   int logticks;              /* Are major ticks logarithmically spaced? */
   int ncross;                /* No. of crossings */
   int ndisc;                 /* No. of discontinuities along the edge */
   int nsum;                  /* Number of values summed in "sum" */
   int plarger;               /* Was previous axis value larger than target? */

/* Get a pointer to the supplied statics object. */
   statics = *pstatics;

/* If a NULL Plot pointer has been supplied, release the static
   resources, and return. */
   if( !this ){
      if( statics ){
         if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
         if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
         if( statics->pset4 ) statics->pset4 = astAnnul( statics->pset4 );
         if( statics->frame ) statics->frame = astAnnul( statics->frame );
         *pstatics = astFree( statics );
      }
      return 0;
   }

/* Initialise the number of crossings found, and the pointer to the place
   to store them. */
   ncross = 0;
   *cross = NULL;

/* Check the global status. */
   if( !astOK ) return 0;

/* If no statics structure was supplied, create one now and initialise it. */
   if( !statics ) {
      statics = astMalloc( sizeof( EdgeCrossingsStatics ) );
      if( statics ) {
         statics->frame = NULL;
         statics->pset1 = NULL;
         statics->pset2 = NULL;
         statics->pset4 = NULL;
         statics->ptr1 = NULL;
         statics->ptr2 = NULL;
         statics->ptr4 = NULL;
         statics->paxis = -1;
         statics->pedge = -1;
         *pstatics = statics;
      }
   }

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   pp2 = 0.0;
   pv1 = 0.0;
   pv2 = 0.0;
   plarger = 0;

/* See if the major ticks on the other axis are logarithmically or
   linearly spaced. */
   logticks = astGetLogTicks( this, 1 - axis );

/* Ensure that "edge" is in the range 0 - 3. */
   edge = edge % 4;
   if( edge < 0 ) edge = -edge;

/* If the edge or axis has changed since the last invocation, or if this is
   the first invocation, initialise some static data. */
/* ======================================================================*/
   if( statics->pedge == -1 || statics->pedge != edge || statics->paxis != axis ){

/* Save the edge and axis. */
      statics->pedge = edge;
      statics->paxis = axis;

/* Annull any previous static data objects */
      if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
      if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
      if( statics->pset4 ) statics->pset4 = astAnnul( statics->pset4 );
      if( statics->frame ) statics->frame = astAnnul( statics->frame );

/* Store some values so that the code does not need to consider each edge
   separately. First deal with the left hand edge. */
      if( edge == 0 ){
         statics->edgeax = 0;
         if( this->xrev ){
            statics->edgeval = this->xhi;
         } else {
            statics->edgeval = this->xlo;
         }
         statics->edgehi = this->yhi;
         statics->edgelo = this->ylo;

/* Now deal with the right hand edge. */
      } else if( edge == 2 ){
         statics->edgeax = 0;
         if( this->xrev ){
            statics->edgeval = this->xlo;
         } else {
            statics->edgeval = this->xhi;
         }
         statics->edgehi = this->yhi;
         statics->edgelo = this->ylo;

/* Now deal with the bottom edge. */
      } else if( edge == 3 ){
         statics->edgeax = 1;
         if( this->yrev ){
            statics->edgeval = this->yhi;
         } else {
            statics->edgeval = this->ylo;
         }
         statics->edgehi = this->xhi;
         statics->edgelo = this->xlo;


/* Finally deal with the top edge. */
      } else {
         statics->edgeax = 1;
         if( this->yrev ){
            statics->edgeval = this->ylo;
         } else {
            statics->edgeval = this->yhi;
         }
         statics->edgehi = this->xhi;
         statics->edgelo = this->xlo;

      }

/* Get a pointer to the current Frame in the supplied Plot. */
      statics->frame = astGetFrame( this, AST__CURRENT );

/* Get a pointer to the mapping from base to current Frame in the supplied
   Plot. */
      mapping = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Create a PointSet to hold the graphics coordinates at a set of
   regularly spaced points along the specified edge of the plotting area. */
      pset1a = astPointSet( EDGETICKS_DIM, 2, "", status );
      ptr1a = astGetPoints( pset1a );

/* Create a PointSet to hold the corresponding physical coordinates. */
      pset2a = astPointSet( EDGETICKS_DIM, 2, "", status );
      ptr2a = astGetPoints( pset2a );

/* Check they can be used. */
      if( astOK ){

/* Set up the graphics coordinates. */
         dd = ( statics->edgehi - statics->edgelo )/(double)( EDGETICKS_DIM - 1 );
         value = statics->edgelo;

         p1 = ptr1a[ statics->edgeax ];
         p2 = ptr1a[ 1 - statics->edgeax ];

         for( i = 0; i < EDGETICKS_DIM; i++ ){
            *(p1++) = statics->edgeval;
            *(p2++) = value;
            value += dd;
         }
      }

/* Transform the graphics coordinates to physical coordinates,
   *without* normalising them into their normal ranges. */
      (void) Trans( this, statics->frame, mapping, pset1a, 1, pset2a, 0, method, class, status );

/* Find the RMS step size along the axis. This is used to locate
   discontinuities along the edge.  Do three rejection iterations. */
      statics->limit = DBL_MAX;
      for( iter = 0; iter < 3; iter ++ ){
         q1 = ptr2a[ axis ];
         pq1 = AST__BAD;
         sum = 0.0;
         nsum = 0;

         for( i = 0; i < EDGETICKS_DIM; i++ ){
            if( *q1 != AST__BAD && pq1 != AST__BAD ){
               diff = *q1 - pq1;
               if( fabs( diff ) < statics->limit ){
                  sum += diff*diff;
                  nsum++;
               }
            }
            pq1 = *(q1++);
         }

         if( nsum == 0 ) break;
         statics->limit = 3.0*sqrt( sum/(double)nsum );
      }

/* Now create another PointSet holding positions slightly offset from the
   physical coordinates at the edge samples. The offset is in the direction
   of the other physical axis. These positions are used to determine the
   vector at the crossings. */
      if( nsum > 0 ){
         pset3 = astPointSet( EDGETICKS_DIM, 2, "", status );
         ptr3 = astGetPoints( pset3 );

/* Create a PointSet to hold the corresponding graphics coordinates. */
         pset4a = astPointSet( EDGETICKS_DIM, 2, "", status );
         ptr4a = astGetPoints( pset4a );

/* Check they can be used. */
         if( astOK ){

/* Copy the physical coordinates from PointSet 2 to PointSet 3, offseting
   them slightly along the other axis. */
            p1 = ptr2a[ axis ];
            p2 = ptr2a[ 1 - axis ];

            q1 = ptr3[ axis ];
            q2 = ptr3[ 1 - axis ];

            offset = 0.2*gap[ 1 - axis ];

            pq1 = AST__BAD;

            for( i = 0; i < EDGETICKS_DIM; i++ ){
               if( *p1 != AST__BAD && *p2 != AST__BAD ){
                  if( logticks ) offset = 0.2*(*p2)*( gap[ 1 -axis ] - 1.0 );
                  *(q2++) = *p2 + offset;
               } else {
                  *(q2++) = AST__BAD;
               }
               pq1 = *(p1++);
               *(q1++) = pq1;
               p2++;
            }

         }

/* Transform the physical coordinates to graphics coordinates. */
         (void) Trans( this, NULL, mapping, pset3, 0, pset4a, 0, method, class, status );

/* Check they can be used. */
         if( astOK ){

/* Modify the contents of PointSet 4 to represent the unit vector in
   graphics coordinates at each edge sample. */
            p1 = ptr1a[ 0 ];
            p2 = ptr1a[ 1 ];
            q1 = ptr4a[ 0 ];
            q2 = ptr4a[ 1 ];

            for( i = 0; i < EDGETICKS_DIM; i++ ){
               if( *p1 != AST__BAD && *p2 != AST__BAD &&
                   *q1 != AST__BAD && *q2 != AST__BAD ){

                  dx = *q1 - *p1;
                  dy = *q2 - *p2;
                  dl2 = dx*dx + dy*dy;

                  if( dl2 > 0.0 ){
                     dl = sqrt( dl2 );
                     *q1 = dx/dl;
                     *q2 = dy/dl;
                  } else {
                     *q1 = AST__BAD;
                     *q2 = AST__BAD;
                  }

               } else {
                  *q1 = AST__BAD;
                  *q2 = AST__BAD;
               }

               p1++;
               p2++;
               q1++;
               q2++;

            }

         }

/* Annul the PointSet holding offset physical cooridnates. */
         pset3 = astAnnul( pset3 );

/* Discontinuities in the axis values can cause problems. For instance,
   using the above PointSets, no tick mark could be put at 0 hours RA
   because of the discontinuity there. To get round this, 3 extra samples
   are added at each discontinuity, the first extends the continuous section
   which ends at the discontinuity, and the third extends the secion which
   starts at the discontinuity. This results in the two sections overlapping
   by one sample. The second is placed between these two and has a bad
   axis value. It prevents crossings from being found in between the values
   at the ends of the two sections.

   First count the number of discontinuities in the axis values.
   Discontinuites are defined as steps of more than 9 times the RMS step
   size. */
         q1 = ptr2a[ axis ];
         pq1 = AST__BAD;
         statics->limit *= 3.0;
         ndisc = 0;

         for( i = 0; i < EDGETICKS_DIM; i++ ){
            if( *q1 != AST__BAD && pq1 != AST__BAD ){
               if( fabs( *q1 - pq1 ) > statics->limit ) ndisc++;
            }
            pq1 = *(q1++);
         }

/* Store the size of the new PointSets holding the extra samples. */
         statics->dim = EDGETICKS_DIM + 3*ndisc;

/* If there are no discontinuities, just clone the existing PointSets. */
         if( !ndisc ){
            statics->pset1 = astClone( pset1a );
            statics->pset2 = astClone( pset2a );
            statics->pset4 = astClone( pset4a );
            statics->ptr1 = astGetPoints( statics->pset1 );
            statics->ptr2 = astGetPoints( statics->pset2 );
            statics->ptr4 = astGetPoints( statics->pset4 );

/* Otherwise, create new PointSets. */
         } else {
            statics->pset1 = astPointSet( statics->dim, 2, "", status );
            statics->ptr1 = astGetPoints( statics->pset1 );
            statics->pset2 = astPointSet( statics->dim, 2, "", status );
            statics->ptr2 = astGetPoints( statics->pset2 );
            statics->pset4 = astPointSet( statics->dim, 2, "", status );
            statics->ptr4 = astGetPoints( statics->pset4 );

/* Set up pointers used to walk through the arrays in the original
   PointSets and the new PointSets. */
            p1 = statics->ptr1[ 0 ];
            p2 = statics->ptr1[ 1 ];
            q1 = statics->ptr2[ axis ];
            q2 = statics->ptr2[ 1 - axis ];
            v1 = statics->ptr4[ 0 ];
            v2 = statics->ptr4[ 1 ];

            p1a = ptr1a[ 0 ];
            p2a = ptr1a[ 1 ];
            q1a = ptr2a[ axis ];
            q2a = ptr2a[ 1 - axis ];
            v1a = ptr4a[ 0 ];
            v2a = ptr4a[ 1 ];

/* Initialise the axis value at the previous sample. */
            pq1 = AST__BAD;

/* Check all samples in the original PointSets. */
            for( i = 0; i < EDGETICKS_DIM; i++ ){

/* If this is the first point after a discontinuity... */
               if( *q1a != AST__BAD && pq1 != AST__BAD ){
                  if( fabs( *q1a - pq1 ) > statics->limit ) {

/* Insert an extra sample with the coordinates of the previous sample,
   but with an axis value which is linearly extrapolated from the previous
   samples. */
                     *(p1++) = p1a[ 0 ];
                     *(p2++) = p2a[ 0 ];
                     *(v1++) = v1a[ -1 ];
                     *(v2++) = v2a[ -1 ];
                     *(q2++) = q2a[ -1 ];
                     if( i > 1 && q1a[ -2 ] != AST__BAD ){
                        *(q1++) = 2.0*pq1 - q1a[ -2 ];
                     } else {
                        *(q1++) = pq1;
                     }

/* Insert an extra sample with bad coordinates. */
                     *(p1++) = AST__BAD;
                     *(p2++) = AST__BAD;
                     *(v1++) = AST__BAD;
                     *(v2++) = AST__BAD;
                     *(q2++) = AST__BAD;
                     *(q1++) = AST__BAD;

/* Insert an extra sample with the cooridnates of the current sample,
   but with an axis value which is linearly extrapolated from the
   subsequent samples. */
                     *(p1++) = p1a[ -1 ];
                     *(p2++) = p2a[ -1 ];
                     *(v1++) = *v1a;
                     *(v2++) = *v2a;
                     *(q2++) = *q2a;
                     if( i < EDGETICKS_DIM - 1 && q1a[ 1 ] != AST__BAD ){
                        *(q1++) = 2.0*(*q1a) - q1a[ 1 ];
                     } else {
                        *(q1++) = pq1;
                     }

                  }

               }

/* Save the current axis value. */
               pq1 = *q1a;

/* Copy the current input values to the new PointSets, and move on the next
   point in the original PointSets. */
               *(p1++) = *(p1a++);
               *(p2++) = *(p2a++);
               *(q1++) = *(q1a++);
               *(q2++) = *(q2a++);
               *(v1++) = *(v1a++);
               *(v2++) = *(v2a++);

            }

         }

/* Anull the original PointSets. */
         pset4a = astAnnul( pset4a );

/* If all the physical coordinates are bad, indicate this by setting the
   limiting step size bad. */
      } else {
         statics->limit = AST__BAD;
      }

/* Anull the original PointSets. */
      pset1a = astAnnul( pset1a );
      pset2a = astAnnul( pset2a );

/* Annul the pointer to the mapping from base to current Frame. */
      mapping = astAnnul( mapping );

   }

/* ======================================================================*/
/* The initialisation has now been done. Check the physical coordinate data
   can be used. */
   if( astOK && statics->limit != AST__BAD ){

/* Store pointers to the graphics and physical coordinates at the first
   edge sample. */
      p1 = statics->ptr1[ statics->edgeax ];     /* Graphics axis with constant value */
      p2 = statics->ptr1[ 1 - statics->edgeax ]; /* Graphics axis with varying value */
      q1 = statics->ptr2[ axis ];       /* Physical axis values to be searched */
      q2 = statics->ptr2[ 1 - axis ];   /* The other physical axis */

/* Store pointers to the components of the unit vector at the first
   edge sample. */
      v1 = statics->ptr4[ 0 ];
      v2 = statics->ptr4[ 1 ];

/* Inidicate that there is currently no "previous sample". */
      pq1 = AST__BAD;

/* Check each point in turn... */
      for( i = 0; i < statics->dim; i++ ){

/* Skip this point if the physical coordinates are undefined. */
         if( *q1 != AST__BAD && *q2 != AST__BAD ){

/* Get a flag indicating if the required axis value has been exceeded at
   the current edge sample. */
            larger = ( *q1 > axval );

/* If the state of this flag has changed since the previous edge sample,
   and if we know where the previous sample was, we have found a
   crossing. */
            if( pq1 != AST__BAD && larger != plarger ){

/* Find the distance from the previous physical axis value to the required
   axis value, as a fraction of the distance from the previous axis value
   to the current axis value. Since the flag has changed, we know that the
   q1 value at this edge sample and the previous one must be different, so
   we know that the denominator is not zero. */
               f = ( axval - pq1 )/( *q1 - pq1 );

/* Use linear interpolation to estimate the graphics axis value at the
   crossing. */
               if( f != -1.0 ){
                  z = pp2 + f*( *p2 - pp2 );

/* Use linear interpolation to estimate the two components of the unit
   vector at the crossing. */
                  if( *v1 != AST__BAD && pv1 != AST__BAD &&
                      *v2 != AST__BAD && pv2 != AST__BAD ){
                     vx = pv1 + f*( *v1 - pv1 );
                     vy = pv2 + f*( *v2 - pv2 );

/* Normalise the vector. */
                     dl2 = vx*vx + vy*vy;
                     if( dl2 > 0.0 ){
                        dl = sqrt( dl2 );
                        vx /= dl;
                        vy /= dl;
                     } else {
                        vx = AST__BAD;
                        vy = AST__BAD;
                     }

                  } else {
                     vx = AST__BAD;
                     vy = AST__BAD;
                  }

/* Grow the returned array to hold another crossing. */
                  ncross++;
                  *cross = (double *) astGrow( (void *) *cross, ncross,
                                               4*sizeof( double ) );

/* If succesful, store the crossing. */
                 if( astOK ) {

                    data = *cross + 4*( ncross - 1 );
                    if( statics->edgeax ){
                       *(data++) = z;
                       *(data++) = statics->edgeval;
                    } else {
                       *(data++) = statics->edgeval;
                       *(data++) = z;
                    }
                    *(data++) = vx;
                    *(data++) = vy;

                  }

               }

            }

/* Save the flag for use on the next pass through this loop. */
            plarger = larger;

         }

/* Save the varying graphics axis value and the required physical axis
   value at the current edge sample (also save the vector). */
         pp2 = *p2;
         pq1 = *q1;
         pv1 = *v1;
         pv2 = *v2;

/* Point to the next edge sample. */
         p1++;
         p2++;
         q1++;
         q2++;
         v1++;
         v2++;

      }

   }

/* If an error has occurred, free the array holding the crossings, and
   indicate that there are zero corssing. */
   if( !astOK ) {
      *cross = (double *) astFree( (void *) *cross );
      ncross = 0;
   }

/* Return the answer. */
   return ncross;

}

int astFindEscape_( const char *text, int *type, int *value, int *nc, int *status ){
/*
*+
*  Name:
*     astFindEscape

*  Purpose:
*     Check if a string starts with a graphics escape sequence.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     int astFindEscape( const char *text, int *type, int *value, int *nc )

*  Description:
*     This function returns a flag indiciating if the first character in
*     the supplied string is the start of a graphics escape sequence. If
*     so, the type and associated value (if any) of the escape sequence
*     are returned in "type" and "value", and the number of characters
*     occupied by the escape sequence is returned in "nc". If the
*     supplied text string does not begin with an escape sequence, the
*     number of characters before the first escape sequence is returned in
*     "nc" (the length of the string is returned in "nc" if the string
*     contains no escape sequences).
*
*     This function can be used by grf modules which wish to implement
*     interpretation of escape sequences internally, rather than allowing the
*     Plot class to do the interpretation.

*  Parameters:
*     text
*        Pointer to the string to be checked.
*     type
*        Pointer to a location at which to return the type of escape
*        sequence. Each type is identified by a symbolic constant defined
*        in grf.h. The returned value is undefined if the supplied text
*        does not begin with an escape sequence.
*     value
*        Pointer to a lcation at which to return the integer value
*        associated with the escape sequence. All usable values will be
*        positive. Zero is returned if the escape sequence has no associated
*        integer. A value of -1 indicates that the attribute identified by
*        "type" should be reset to its "normal" value (as established using
*        the astGAttr function, etc). The returned value is undefined if the
*        supplied text does not begin with an escape sequence.
*     nc
*        Pointer to a location at which to return the number of
*        characters read by this call. If the text starts with an escape
*        sequence, the returned value will be the number of characters in
*        the escape sequence. Otherwise, the returned value will be the
*        number of characters prior to the first escape sequence, or the
*        length of the supplied text if no escape sequence is found.

*  Returned Value:
*     A non-zero value is returned if the supplied text starts with a
*     graphics escape sequence, and zero is returned otherwise.

*  Escape Sequences:
*     Escape sequences are introduced into the text string by a percent
*     "%" character. The following escape sequences are currently recognised
*     ("..." represents a string of one or more decimal digits):
*
*       %%      - Print a literal "%" character.
*
*       %^...+  - Draw subsequent characters as super-scripts. The digits
*                 "..." give the distance from the base-line of "normal"
*                 text to the base-line of the super-script text, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*       %^+     - Draw subsequent characters with the normal base-line.
*
*       %v...+  - Draw subsequent characters as sub-scripts. The digits
*                 "..." give the distance from the base-line of "normal"
*                 text to the base-line of the sub-script text, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*
*       %v+     - Draw subsequent characters with the normal base-line
*                 (equivalent to %^+).
*
*       %>...+  - Leave a gap before drawing subsequent characters.
*                 The digits "..." give the size of the gap, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*
*       %<...+  - Move backwards before drawing subsequent characters.
*                 The digits "..." give the size of the movement, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text.
*
*       %s...+  - Change the Size attribute for subsequent characters. The
*                 digits "..." give the new Size as a fraction of the
*                 "normal" Size, scaled so that a value of "100" corresponds
*                 to 1.0;
*
*       %s+     - Reset the Size attribute to its "normal" value.
*
*       %w...+  - Change the Width attribute for subsequent characters. The
*                 digits "..." give the new width as a fraction of the
*                 "normal" Width, scaled so that a value of "100" corresponds
*                 to 1.0;
*
*       %w+     - Reset the Size attribute to its "normal" value.
*
*       %f...+  - Change the Font attribute for subsequent characters. The
*                 digits "..." give the new Font value.
*
*       %f+     - Reset the Font attribute to its "normal" value.
*
*       %c...+  - Change the Colour attribute for subsequent characters. The
*                 digits "..." give the new Colour value.
*
*       %c+     - Reset the Colour attribute to its "normal" value.
*
*       %t...+  - Change the Style attribute for subsequent characters. The
*                 digits "..." give the new Style value.
*
*       %t+     - Reset the Style attribute to its "normal" value.
*
*       %h+     - Remember the current horizontal position (see "%g+")
*
*       %g+     - Go to the horizontal position of the previous "%h+" (if any).
*
*       %-      - Push the current graphics attribute values onto the top of
*                 the stack (see "%+").
*
*       %+      - Pop attributes values of the top the stack (see "%-"). If
*                 the stack is empty, "normal" attribute values are restored.

*  Notes:
*     -  Zero is returned if an error has already occurred.
*-
*/

/* Local Variables: */
   int result;
   const char *a;
   const char *b;
   int nd;
   const char *perc;

/* Initialise */
   result = 0;
   *type = GRF__ESPER;
   *value = 0;
   *nc = 0;
   perc = NULL;

/* Check inherited status and supplied pointer. */
   if( !astOK || !text ) return result;

/* Loop round, looking for percent signs. Break out of the loop when a
   complete escape sequence has been found and read, leaving the "b" pointer
   pointing to the first character following the escape sequence. */
   b = NULL;
   a = text;
   while( ( a = strchr( a, '%' ) ) ) {
      perc = a;

/* Compare the following character to each known escape sequence type. */
      a++;
      if( *a == '%') {
         *type = GRF__ESPER;
         b = a + 1;
         break;

      } else if( *a == '^') {
         *type = GRF__ESSUP;

      } else if( *a == 'v') {
         *type = GRF__ESSUB;

      } else if( *a == '>') {
         *type = GRF__ESGAP;

      } else if( *a == '<') {
         *type = GRF__ESBAC;

      } else if( *a == 's') {
         *type = GRF__ESSIZ;

      } else if( *a == 'w') {
         *type = GRF__ESWID;

      } else if( *a == 'f') {
         *type = GRF__ESFON;

      } else if( *a == 'c') {
         *type = GRF__ESCOL;

      } else if( *a == 'g') {
         *type = GRF__ESG;

      } else if( *a == 'h') {
         *type = GRF__ESH;

      } else if( *a == 't') {
         *type = GRF__ESSTY;

      } else if( *a == '-') {
         *type = GRF__ESPSH;
         b = a + 1;
         break;

      } else if( *a == '+') {
         *type = GRF__ESPOP;
         b = a + 1;
         break;

/* If the next character is illegal, skip to the next percent sign. */
      } else {
         continue;
      }

/* The escape sequence looks legal so far, so move on to the next
   character (if any). */
      if( *(++a) ){

/* If the next character is a "+" sign, the attribute needs to be reset
   to its "normal" value. Indicate this by returning a value of "-1" (all
   usable values will be positive). */
         if( *a == '+' ) {
            *value = -1;
            b = a + 1;
            break;

/* Otherwise, to be a legal escape sequence, this character must be the
   first in a sequence of digits, terminated by a "+" sign.*/
         } else if( (nd = 0, astSscanf( a, "%d%n+", value, &nd ))) {
            b = a + nd + 1;
            break;
         }
      }
   }

/* Was a usable escape sequence found at the start of the supplied text?
   If so, return a function value of 1 and store the number of characters in
   the escape sequence. */
   if( b && perc == text ) {
      result = 1;
      *nc = b - perc;

/* Otherwise, return the preset function value of zero. If an escape
   sequence was found later in the text, return the number of characters
   prior to the escape sequence. */
   } else if( b ) {
      *nc = perc - text;

/* Otherwise, if no escape sequence was found, return the length of the
   supplied text. */
   } else {
      *nc = strlen( text );
   }

/* Return the result. */
   return result;
}

static int FindMajTicks( AstMapping *map, AstFrame *frame, int axis,
                         double refval, double width, double gap, double *cen, int ngood,
                         double *data, double **tick_data, int *status ){
/*
*  Name:
*     FindMajTicks

*  Purpose:
*     Place the major tick marks for a physical coordinate axis.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int FindMajTicks( AstMapping *map, AstFrame *frame, int axis,
*                       double refval, double width, double gap, double *cen, int ngood,
*                       double *data, double **tick_data )

*  Class Membership:
*     Plot member function.

*  Description:
*     The caller supplies an array of axis values (non-normalized), sorted
*     into ascending order (with any bad values at the end), together with
*     the gap size for the axis. The array of axis values is assumed to cover
*     the entire range which the axis can take within the plotting zone. The
*     first tick mark is placed just below the smallest axis value, at a
*     position which is an integral number of gaps away from the value
*     supplied in "cen" (if a value of AST__BAD is supplied for "cen" then
*     "cen = 0.0" is assumed). Notionally, tick marks are then placed at
*     intervals given by "gap" all the way upto, and just beyond, the
*     largest axis value. However, it could be that large sections of the
*     axis are not actually present within the plotting zone. For instance,
*     an RA axis covering the two hour range from 23h to 1h (centred on
*     0h), will have some values at zero and some at 23.999.., but there
*     will be a large range inbetween these limits which is not represented
*     in the plotting area (i.e. the 22h range from 1h to 23h centred on
*     12h). For this reason, tick marks are removed if there are no axis
*     values inbetween the tick mark and either of its neighbours. However,
*     small "holes" in the axis coverage are allowed, and ticks marks are
*     returned covering such small holes. Extra tick marks are also placed
*     at each end of the range to guard against the supplied array of axis
*     values not entirely covering the range of axis values in the plotting
*     area.
*
*     For SkyFrames, positions which have latitude values outside the
*     normal ranges are ignored. Longitude ranges are not checked to
*     avoid problems with CAR projections.
*
*     The returned tick mark values are placed into their primary domain
*     using the Norm1 method, but are NOT normalised using the astNorm
*     method for the supplied Frame. Duplicate tick marks values are
*     removed from the returned list.

*  Parameters:
*     map
*        Mapping from the Plot Base Frame to Plot Current Frame.
*     frame
*        Pointer to the Frame.
*     axis
*        Zero-based index of the axis being used.
*     refval
*        Value to use for the other axis (index [1-axis]) when placing
*        the tick mark values into their primary domain.
*     width
*        Range of used values on the other axis (index [1-axis]).
*     gap
*        The supplied value for the gaps between ticks on the axis.
*     cen
*        Pointer to the supplied axis value at which to put a central tick.
*        Other ticks will be placed evenly on either side of this tick. If
*        AST__BAD is provided, a value will be used which would put a tick
*        at an axis value of zero. The used value is returned.
*     ngood
*        The number of good values in the array pointer to by "data" (i.e.
*        values not equal to AST__BAD).
*     data
*        A pointer to an array holding sorted axis values (non-normalized)
*        covering the entire plotting area.
*     tick_data
*        A pointer to a place at which to store a pointer to an array
*        holding the returned tick mark values for the axis.

*  Returned Value:
*     The number of major tick mark values stored in the array pointer to
*     by "*tick_data".

*  Notes:
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned in "tick_data", and zero
*     is returned for the function value.
*/

/* Local Variables: */
   double *r;         /* Pointer to next tick value to be read */
   double *ticks;     /* Pointer to the axis values at the major tick marks */
   double *w;         /* Pointer to last tick value to be written */
   double bot;        /* Lowest axis value to be displayed */
   double centre;     /* The axis value at the first tick mark */
   double delta;      /* A safe distance from an axis limit */
   double f;          /* The nearest acceptable tick mark index */
   double tmp;        /* Temporary storage */
   double top;        /* Highest axis value to be displayed */
   int inc;           /* This times increase in nticks */
   int k;             /* Tick mark index */
   int linc;          /* Last times increase in nticks */
   int nfill;         /* No of tick marks to extend by at edges of coverage */
   int nsame;         /* Number of equal inc values there have been */
   int nticks;        /* Number of major tick marks used */
   int ntnew;         /* This times new value of nticks */
   int use_nfill;     /* nfill value which started this run of equal inc values */

/* Initialise the returned pointer. */
   *tick_data = NULL;

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   nsame = 0;
   use_nfill = 0;

/* Decide where to put the first major tick. Use any value supplied by
   the caller. Otherwise put it an integral number of gaps away from the
   origin. This would result in the origin being at a major tick mark. */
   if( cen && *cen != AST__BAD ) {
      centre = *cen;
   } else {
      centre = astCentre( frame, axis, data[ 0 ], gap );
      if( cen ) *cen = centre;
   }

/* Find the number of candidate tick marks assuming an nfill value of 0. */
   nfill = 0;
   nticks = FindMajTicks2( nfill, gap, centre, ngood, data, &ticks, status );

/* Loop round increasing the nfill value until an unreasonably large value
   of nfill is reached. The loop will exit early via a break statement when
   all small holes in the axis coverage are filled in. */
   linc = -100000;
   while( nfill < 100 && astOK ){

/* Increment the number of ticks added as "padding" at the edges of any
   gaps in the coverage of axis values. */
      nfill++;

/* Form a new set of tick mark values using this new nfill value */
      ticks = (double *) astFree( (void *) ticks );
      ntnew = FindMajTicks2( nfill, gap, centre, ngood, data, &ticks, status );

/* We need to know if the rate of increase of nticks has settled down to
   a constant value. Inititially increasing nfill will cause the total
   number of ticks (nticks) to increase rapidly. But this rate of
   increase will get less as any small gaps in axis coverage are filled in.
   We break out of the while loop when the rate of increase has settled
   down to a constant value (indicating that only very large holes are left
   in the axis coverage). Find the increase in the number of ticks caused by
   the increase in the nfill value made in this loop. If this increase is the
   same as the increase caused by the previous loop, increment the number of
   equal increases there have been. If the increase is different to last time,
   reset the number of equal increases to zero. */
      inc = ntnew - nticks;
      if( inc == linc ) {
         nsame++;
      } else {
         nsame = 0;
         use_nfill = nfill;
      }

/* If the past 3 increases in nfill has not caused any change in the rate
   of increase of nticks, then re-create the ticks for the value of nfill
   which started the current run of equal increment values, and leave the
   loop. */
      if( nsame == 3 ) {
         ticks = (double *) astFree( (void *) ticks );
         nticks = FindMajTicks2( use_nfill, gap, centre, ngood, data, &ticks, status );
         break;
      }

/* Save this times values for use in the next loop. */
      linc = inc;
      nticks = ntnew;
   }

/* Remove ticks which are not within the axis ranges to be displayed.
   Ticks which are very close to the limit are moved to a safe (but
   visually negligable) distance away from the limit). */
   bot = astGetBottom( frame, axis );
   top = astGetTop( frame, axis );
   if( bot > top ) {
      tmp = top;
      top = bot;
      bot = tmp;
   }
   delta = 0.05*gap;
   r = ticks;
   for( k = 0; k < nticks; k++ ){
      if( *r != AST__BAD ) {
         if( fabs( *r - bot ) < delta ) {
            *r = bot + delta;
         } else if( fabs( *r - top ) < delta ) {
            *r = top - delta;
         } else if( *r < bot || *r > top ) {
            *r = AST__BAD;
         }
      }
      r++;
   }

/* Use the Mapping to place each tick mark value in its primary domain.
   This is a sort of normalization, similar but different to that performed
   by the astNorm method. */
   Norm1( map, axis, nticks, ticks, refval, width, status );

/* Check for success. */
   if( astOK ){

/* Ensure that all ticks marks are offset from the "centre" value by an
   integer multiple of the gap size. This is done by changing each tick
   value to the closest acceptable value. Also ensure that values close to
   zero (i.e. less than 1E-10 of the gap size) are set exactly to zero. */
      r = ticks;
      for( k = 0; k < nticks; k++ ){
         if( *r != AST__BAD ) {
            f = floor( 0.5 + ( *r - centre )/gap );
            *r = f*gap + centre;
            if( fabs( *r ) < 1.0E-10*gap ) *r = 0.0;
            r++;
         } else {
            r++;
         }
      }

/* Sort the tick values into increasing order. */
      qsort( (void *) ticks, (size_t) nticks, sizeof(double), Compared );

/* Remove any duplicate or BAD tick values by shuffling the higher unique
   values down to over-write them. We subtract the centre value of both
   tick values before comparing them for equality in order to avoid
   unnecessarily removing tick marks in high precsion data. */
      r = ticks + 1;
      w = ticks;
      for( k = 1; k < nticks && astOK; k++ ){
         if( *r != AST__BAD && !astEQUALS( *r-centre, *w-centre, 1.0E8 ) ){
            w++;
            *w = *r;
         }
         r++;
      }

/* Modify the number of ticks to exclude the duplicate ones. */
      nticks = (int) ( w - ticks ) + 1;

   }

/* If an error has occurred, free the memory holding the major tick mark
   values, and indicate that zero tick marks have been found. */
   if( !astOK ){
      ticks = (double *) astFree( (void *) ticks );
      nticks = 0;
   }

/* Store the pointer to the major tick mark values. */
   *tick_data = ticks;

/* Return the number of major ticks. */
   return nticks;

}
static int FindMajTicks2( int nfill, double gap, double centre, int ngood,
                          double *data, double **tick_data, int *status ){
/*
*  Name:
*     FindMajTicks2

*  Purpose:
*     Find candidate major tick marks for FindMajTicks.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int FindMajTicks2( int nfill, double gap, double centre, int ngood,
*                        double *data, double **tick_data, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     A service routine for function FindMajTicks.

*  Parameters:
*     nfill
*        Number of tick marks to extend by at edges of coverage
*     gap
*        The supplied value for the gaps between ticks on the axis.
*     centre
*        The supplied axis value at which to put a central tick.
*     ngood
*        The number of good values in the array pointer to by "data" (i.e.
*        values not equal to AST__BAD).
*     data
*        A pointer to an array holding sorted axis values covering the
*        entire plotting area.
*     tick_data
*        A pointer to a place at which to store a pointer to an array
*        holding the returned tick mark values for the axis.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The number of major tick mark values stored in the array pointer to
*     by "*tick_data".

*  Notes:
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned in "tick_data", and zero
*     is returned for the function value.
*/

/* Local Variables: */
   double *ticks;     /* Pointer to the axis values at the major tick marks */
   int i;             /* Index of current axis value */
   int j;             /* Index of filled in tick */
   int k;             /* Tick mark index */
   int klast;         /* Index of the previous tick mark */
   int nticks;        /* Number of major tick marks used */

/* Initialise the returned pointer. */
   *tick_data = NULL;

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   nticks = 0;

/* Reserve memory to hold a reasonable number of tick mark axis values.
   This memory is later extended as necessary. */
   ticks = (double *) astMalloc( sizeof(double)*( 6*nfill + 14 ) );

/* Check that the pointer can be used. */
   if( astOK ){

/* Put the first tick marks just below the lowest axis value (in case
   the grid did not sample the entire range of the axis). */
      k = floor( ( data[ 0 ] - centre )/gap );

      for ( i = 0; i < nfill; i++ ){
         ticks[ i ] = gap*(double)( k - nfill + i ) + centre;
      }
      ticks[ nfill ] = gap*(double)( k ) + centre;

/* Initialise the number of major tick marks found so far. */
      nticks = nfill + 1;

/* Loop round each of the remaining good ordered axis values. */
      klast = k;
      for( i = 1; i < ngood && astOK; i++ ) {

/* Find the tick marks enclosing the axis value. The tick mark placed at
   "centre" is called tick mark zero, and tick marks are indexed (positive
   or negative) from an origin at "centre". Find the index of the more
   negative of the two tick marks enclosing the axis value. */
         k = floor( ( data[ i ] - centre )/gap );

/* Ensure that the tick marks enclosing the current axis value are used.
   Some extra tick marks are used at the start and end of any gaps in
   the axis coverage. This is done to "fill in" small holes caused by the
   grid of physical coordinate values not completely covering the
   plotting area. Large holes, such as occur on an RA axis covering the 2
   hour range from 23 hours to 1 hour are left without any tick marks in
   them (the "hole" in this case is the 22 hours range from 1 hour to 23
   hours). */
         for( j = 0; j < nfill + 1; j++ ){
            if( k - klast > nfill + 2 - j ) {
               ticks = (double *) astGrow( ticks, nticks + 1, sizeof( double ) );
               if( astOK ) ticks[ nticks++ ] =
                                 gap*(double)( klast + nfill + 1 - j ) + centre;
            }
            if( k - klast > nfill - j ) {
               ticks = (double *) astGrow( ticks, nticks + 1, sizeof( double ) );
               if( astOK ) ticks[ nticks++ ] =
                                 gap*(double)( k - nfill + j ) + centre;
            }
         }

/* Save the index of the current tick mark. */
         klast = k;

      }

/* Add extra tick marks beyond the end in case the grid did not sample
   the entire range of the axis. */
      ticks = (double *) astGrow( ticks, nticks + nfill + 1, sizeof( double ) );
      for( i = 0; i < nfill && astOK; i++ ){
         ticks[ nticks++ ] = gap*(double)( klast + i + 1 ) + centre;
      }

   }

/* If an error has occurred, free the memory holding the major tick mark
   values, and indicate that zero tick marks have been found. */
   if( !astOK ){
      ticks = (double *) astFree( (void *) ticks );
      nticks = 0;
   }

/* Store the pointer to the major tick mark values. */
   *tick_data = ticks;

/* Return the number of major ticks. */
   return nticks;

}

static int FindDPTZ( AstFrame *fr, int axis, const char *fmt,
                      const char *text, int *ndp, int *ntz, int *status ) {
/*
*  Name:
*     FindDPTZ

*  Purpose:
*     Find the number of decimal places and trailing zeros in a label.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int FindDPTZ( AstFrame *fr, int axis, const char *fmt,
*                   const char *text, int *ndp, int *ntz, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied label is split into fields using the astFields method of
*     the supplied frame. The number of decimal places in the last
*     field is returned in *ndp, and the total number of trailing zeros
*     (excluding exponents) is returned in *ntz.

*  Parameters:
*     fr
*        The frame.
*     axis
*        The axis index to which the label applies.
*     fmt
*        The format string used to format the label.
*     text
*        The text of the label.
*     ndp
*        Pointer to an int in which to return the number of decimal
*        places in the final field.
*     ntz
*        Pointer to an int in which to return the number of trailing zeros.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Non-zero if and only if a non-zero digit is found in any field.

*/

/* Local Constants: */
#define MAXFLD 10

/* Local Variables: */
   char *fields[ MAXFLD ];
   const char *a;
   const char *dot;
   const char *ff;
   double junk;
   int fnc;
   int i;
   int j;
   int l;
   int mxnd;
   int nc[ MAXFLD ];
   int nf;
   int result;

/* Initialise */
   *ndp = 0;
   *ntz = 0;
   result = 0;

/* Check inherited status */
   if( !astOK ) return result;

/* Split the label up into fields. */
   nf = astFields( fr, axis, fmt, text, MAXFLD, fields, nc, &junk );
   if( nf > 0 ) {

/* Search the last fields (assumed to be the least significant) for a
   decimal point. */
      ff = fields[ nf - 1 ];
      fnc = nc[ nf - 1 ];
      dot = strchr( ff, '.' );
      if( dot && ( ff - dot >= fnc ) ) dot = NULL;

/* Find the number of digits following the decimal point. */
      if( dot ) {
         *ndp = strspn( dot + 1, "0123456789" );
         mxnd = fnc - ( dot - ff ) - 1;
         if( *ndp > mxnd ) *ndp =  mxnd;
      } else {
         *ndp = 0;
      }

/* Loop through all the fields, from least significant to most significant,
   counting the number of trailing zeros. */
      *ntz = 0;
      for( i = nf - 1; i >= 0; i-- ) {
         l = strspn( fields[ i ], "-+0123456789." );
         if( l > nc[ i ] ) l = nc[ i ];
         a = fields[ i ] + l - 1;
         for( j = l - 1; j >= 0; j--,a-- ){
            if( *a == '0' ) {
               (*ntz)++;
            } else if( isdigit( *a ) ) {
               result = 1;
               break;
            }
         }
         if( j >= 0 ) break;
      }
   }

/* Return the result. */
   return result;

/* Undefine local constants: */
#undef MAXFLD

}

static int FindString( int n, const char *list[], const char *test,
                       const char *text, const char *method,
                       const char *class, int *status ){
/*
*  Name:
*     FindString

*  Purpose:
*     Find a given string within an array of character strings.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int FindString( int n, const char *list[], const char *test,
*                     const char *text, const char *method, const char *class,
*                     int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function identifies a supplied string within a supplied
*     array of valid strings, and returns the index of the string within
*     the array. The test option may not be abbreviated, but case is
*     insignificant.

*  Parameters:
*     n
*        The number of strings in the array pointed to be "list".
*     list
*        A pointer to an array of legal character strings.
*     test
*        A candidate string.
*     text
*        A string giving a description of the object, parameter,
*        attribute, etc, to which the test value refers.
*        This is only for use in constructing error messages. It should
*        start with a lower case letter.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The index of the identified string within the supplied array, starting
*     at zero.

*  Notes:
*     -  A value of -1 is returned if an error has already occurred, or
*     if this function should fail for any reason (for instance if the
*     supplied option is not specified in the supplied list).

*/

/* Local Variables: */
   int ret;                /* The returned index */

/* Check global status. */
   if( !astOK ) return -1;

/* Compare the test string with each element of the supplied list. Leave
   the loop when a match is found. */
   for( ret = 0; ret < n; ret++ ) {
      if( !Ustrcmp( test, list[ ret ], status ) ) break;
   }

/* Report an error if the supplied test string does not match any element
   in the supplied list. */
   if( ret >= n ) {
      astError( AST__OPT, "%s(%s): Illegal value '%s' supplied for %s.", status,
                method, class, test, text );
      ret = -1;
   }

/* Return the answer. */
   return ret;
}

static char *FindWord( char *ptr, const char *d, const char **p, int *status ) {
/*
*  Name:
*     FindWord

*  Purpose:
*     Return a copy of the next word in a supplied string.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     char *FindWord( char *ptr, const char *d, const char **p, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function locates the start and end of the first word in the
*     string pointed to by *p, and returns a copy of the word. The pointer
*     *p is modified to point to the start of the following word (if any).
*     The characters which delimit words are supplied in string "d".

*  Parameters:
*     ptr
*        A pointer to a character string in which to store the returned
*        word. The memory holding this string should have been allocated
*        using one of the functions in the AST "memory" module. The memory
*        area will be modified in size to fit the returned word. A NULL
*        pointer may be supplied if no memory has yet been allocated.
*        Any memory pointed to by ptr is freed if a NULL pointer is
*        returned by this function (i.e. if no word is found).
*     d
*        A string holding the characters which are to be used as word
*        delimiters.
*     p
*        The address of a character string pointer. On entry, this pointer
*        identifies the start of the string to be searched. On exit, it is
*        modified to point to the start of the following word. It is
*        returned NULL if there are no more words.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a dynamically allocated character string holding the
*     next word, or NULL if no word could be found.

*/

/* Local Variables: */
   const char *a, *b, *c;
   char *ret;
   int nc;

/* Free any allocated memory and return if any of the supplied pointers
   (except ptr) is NULL, or if an error has occurred. */
   if( !astOK || !d || !p || !*p ) {
      (void) astFree( (void *) ptr );
      return NULL;
   }

/* Get a pointer to the first character which is not in "d". Terminate
   the loop if a null character is encountered. */
   a = *p;
   while( *a && strchr( d, (int) *a ) ) a++;

/* Get a pointer to the next character which is in "d". Terminate
   the loop if a null character is encountered. */
   b = a;
   while( *b && !strchr( d, (int) *b ) ) b++;

/* Get a pointer to the next character which is not in "d". Terminate
   the loop if a null character is encountered. */
   c = b;
   while( *c && strchr( d, (int) *c ) ) c++;

/* Adjust the supplied pointer so that it points to the start of the next
   word. */
   if( *c ){
      *p = c;
   } else {
      *p = NULL;
   }

/* Get a null-terminated copy of the word between a and b. */
   nc = b - a;
   if( nc > 0 ) {
      ret = (char *) astStore( (void *) ptr, (void *) a, (size_t) (nc + 1) );
      ret[ nc ] = 0;
   } else {
      ret = astFree( (void *) ptr );
   }

   return ret;
}

static const char *SplitValue( AstPlot *this, const char *value, int axis,
                               int *split, int *status ) {
/*
*  Name:
*     FormatValue

*  Purpose:
*     Format a coordinate value for a Frame axis.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     const char *SplitValue( AstPlot *this, const char *value,
*                                    int axis, int *split )

*  Class Membership:
*     Plot member function

*  Description:
*     This function splits long formatted values (such as the date/time
*     format produced by the TimeFrame class) if possible onto two lines
*     by inclusion of Plot escape sequences.

*  Parameters:
*     this
*        Pointer to the Plot.
*     value
*        The formatted coordinate value.
*     axis
*        Indicates whether or not short lines should be split by
*        including a blank first line. If zero, and if "*split" is non-zero,
*        then short lines are put onto the second line,and the first line
*        is blank.
*     split
*        Pointer to an integer that controls behaviour:
*
*        0 - Split the line if it is too long, and return a value of +1
*            in *split.
*        1 - Split the line even if it does not need splitting, making
*            the first line blank and the second line containing all the
*            supplied text (*split is unchanged on exit).

*  Returned Value:
*     A pointer to a static buffer containing a null-terminated string
*     holding the (possibly split) formatted value. This will be a copy of
*     the supplied pointer if the string does not need to be split.

*  Notes:
*     -  A NULL pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*/

/* Local Variables: */
   astDECLARE_GLOBALS
   char *d;
   const char *result;
   float rsp;
   int aft_end;
   int aft_start;
   int bef_end;
   int bef_start;
   int i;
   int id;
   int idmin;
   int imin;
   int l;
   int naft;
   int nbef;
   int nlong;
   int nshort;
   int nsp;

/* Initialise */
   result = value;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Do nothing more if the formatted value already contains graphical
   escape sequences, or if graphical escapes sequences are not being
   interpreted. */
   if( value && astGetEscape( this ) && !HasEscapes( value, status ) ) {

/* Attempt to find a space close to the centre of the formatted string. */
      l = strlen( value );
      idmin = 2*l;
      imin = -1;
      for( i = 0; i < l; i++ ) {
         if( isspace( value[ i ] ) ) {
            id = abs( i - l/2 );
            if( id < idmin ) {
               idmin = id;
               imin = i;
            }
         }
      }

/* We split the line if previous lines have been split (i.e. if *split was
   non-zero on entry) or if this line is long AND it contains a space. This
   means that a sequence of long labels will not be split unless they contain
   spaces. */
      if( *split || ( l > 9 && imin != -1 ) ) {
         *split = 1;

/* Initialse the pointer into the returned buffer at which the next
   character will be placed. */
         d = splitvalue_buff;

/* If no spaces were found... */
         if( imin == -1 ) {

/*  If axis is zero, we add a blank first line. */
            if( axis == 0 ) {

/* Fill the first line with spaces. */
               for( i = 0; i < l; i++ ) *(d++) = ' ';

/* Add an escape sequence that moves down by one character height. */
               d += sprintf( d, "%%v170+" );
            }

/* Add the whole of the supplied text. */
            for( i = 0; i < l; i++ ) *(d++) = value[ i ];

/* If a space was found... */
         } else {

/* Find the first and last non-blank characters before the mid-space. */
            bef_start = -1;
            bef_end = -1;
            for( i = 0; i < imin; i++ ) {
               if( !isspace( value[ i ] ) ) {
                  if( bef_start == -1 ) bef_start = i;
                  bef_end = i;
               }
            }

/* Find the first and last non-blank characters after the mid-space. */
            aft_start = -1;
            aft_end = -1;
            for( i = imin + 1; i < l; i++ ) {
               if( !isspace( value[ i ] ) ) {
                  if( aft_start == -1 ) aft_start = i;
                  aft_end = i;
               }
            }

/* How many significant characters before and after the space? */
            nbef = bef_end - bef_start + 1;
            naft = aft_end - aft_start + 1;

/* Get the lengths of the longer and shorter line. */
            if( nbef > naft ) {
               nlong = nbef;
               nshort = naft;
            } else {
               nlong = naft;
               nshort = nbef;
            }

/* Find the fractional number of spaces before the significant text of the
   shorter line.*/
            rsp = 0.5*( nlong - nshort + 1 );

/* If the top line is the shorter line, put some spaces in at the start. */
            if( nbef < naft ) {
               nsp = (int) rsp;
               for( i = 0; i < nsp; i++ ) *(d++) = ' ';
            }

/* Add the significant text from the top line. */
            for( i = bef_start; i <= bef_end; i++ ) *(d++) = value[ i ];

/* Add an escape sequence that moves down by one character height. */
            d += sprintf( d, "%%v100+" );


/* Add an escape sequence that moves to the left by the required amount. */
            d += sprintf( d, "%%<%d+", (int) ( 60.0*( (float) nlong - rsp )) );

/* Add the significant text from the bottom line. */
            for( i = aft_start; i <= aft_end; i++ ) *(d++) = value[ i ];

         }

/* Terminate it. */
         *d = 0;

/* Return a pointer to the buffer. */
         result = splitvalue_buff;
      }
   }

/* If an error occurred, clear the returned value. */
   if ( !astOK ) result = NULL;

/* Return the result. */
   return result;
}

static void Fpoly( AstPlot *this, const char *method, const char *class,
                   int *status ){
/*
*  Name:
*     Fpoly

*  Purpose:
*     Flush all stored poly lines to the graphics system.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Fpoly( AstPlot *this, const char *method, const char *class,
*                 int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function sends all previously drawn poly lines to the graphics
*     system for rendering, and frees the memory used to hold the poly
*     lines. It attempts to reduce the number of graphics calls by
*     concatenating continuous polylines together.

*  Parameters:
*     this
*        Pointer to the Plot.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS
   float xmid;
   float xt;
   float ymid;
   float *xnew;
   float *ynew;
   int polylen;
   float *xp1;
   float *xp2;
   float *yp1;
   float *yp2;
   float yt;
   int *ekey;
   int *p;
   int *skey;
   int *drawn;
   int ihi;
   int ikey;
   int ilo;
   int imid;
   int ipass;
   int ipoint;
   int ipoly;
   int jpoly;
   int kpoly;
   int *polylist;
   int npoly;
   int np;

/* Check the global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Output any pending polyline. */
   Opoly( this, status );

/* If there is just one polyline to output, just draw it and then free
   the memory used to hold the polyline.  */
   if( Poly_npoly == 1 ) {
      GLine( this, Poly_np[ 0 ], Poly_xp[ 0 ], Poly_yp[ 0 ], method, class,
             status );
      Poly_xp[ 0 ] = astFree( Poly_xp[ 0 ] );
      Poly_yp[ 0 ] = astFree( Poly_yp[ 0 ] );
      Poly_np[ 0 ] = 0;

/* If there are multiple polylines to output, see if any of them can be
   combined before drawing them.  */
   } else if( Poly_npoly > 1 ) {

/* No polyline buffer allocated yet. */
      xnew = NULL;
      ynew = NULL;

/* Allocate an array to hold the order in which polylines should be
   concatenated. Each value in this array will be the index of one of the
   original polylines. A positive index indicates that the polyline
   should be appended in its original order. A negative index indicates
   that the polyline should be appended in reversed order. Polyline zero
   is always appended in its original order. */
      polylist = astMalloc( Poly_npoly*sizeof( int ) );
      npoly = 0;

/* Create an array of drawn, one for each individual polyline. The flag
   is zero if the corresponding polyline has not yet been drawn. */
      drawn = astCalloc(  Poly_npoly, sizeof( int ) );

/* Create two sorted keys for the polylines - one that sorts them into
   increasing x at the start of the polyline, and another that sorts them
   into increasing x at the end of the polyline. */
      skey = astMalloc( Poly_npoly*sizeof( int ) );
      ekey = astMalloc( Poly_npoly*sizeof( int ) );
      if( astOK ) {

         p = skey;
         for( ipoly = 0; ipoly < Poly_npoly; ipoly++ ) *(p++) = ipoly;
         qsort( skey, Poly_npoly, sizeof(int), Fpoly_scmp );

         p = ekey;
         for( ipoly = 0; ipoly < Poly_npoly; ipoly++ ) *(p++) = ipoly;
         qsort( ekey, Poly_npoly, sizeof(int), Fpoly_ecmp );

      }

/* Continue to search for separate polylines that can be combined together
   until we know there are no more. */
      while( astOK ) {

/* Search for the first polyline that has not already been drawn. */
         for( ipoly = 0; ipoly < Poly_npoly; ipoly++ ) {
            if( !drawn[ ipoly ] ) break;
         }

/* Leave the loop if no more polylines remain to be plotted. */
         if( ipoly == Poly_npoly ) break;

/* Initialise the list of polylines to hold the polyline found above, in
   its forward sense. */
         polylist[ 0 ] = ipoly;
         npoly = 1;
         drawn[ 0 ] = 1;

/* Initialise the concatenation point to be the end of the polyline found
   above. Also, initialise the total number of points in the combined
   polyline (polylen). */
         ipoint = Poly_np[ ipoly ] - 1;
         xt = Poly_xp[ ipoly ][ ipoint ];
         yt = Poly_yp[ ipoly ][ ipoint ];
         polylen = ipoint + 1;

/* Loop until we can find no more polylines to append to the list.
   A polyline can be appended if it starts or ends at the current
   concatenation point. */
         while( astOK ) {

/* On the first pass through the next loop, search for a polyline that
   starts at the concatenation point. If no such polyline is found, do
   a second pass in which we search for a polyline that ends at the
   concatenation point. Do not include any previously drawn polylines
   in the search. */
            for( ipass = 0; ipass < 2; ipass++ ) {

/* We use a binary chop to find a polyline which starts (or ends) at the
   x value of the concatenation point. */
               jpoly = -1;
               ilo = 0;
               ihi = Poly_npoly - 1;
               while( 1 ) {
                  imid = ( ilo + ihi )/2;
                  if( ipass == 0 ) {
                     jpoly = skey[ imid ];
                     xmid = Poly_xp[ jpoly ][ 0 ];
                  } else {
                     jpoly = ekey[ imid ];
                     xmid = Poly_xp[ jpoly ][ Poly_np[ jpoly ] - 1 ];
                  }
                  if( astEQUALS( xmid, xt, 1.0E8 ) ) {
                     ikey = imid;
                     break;
                  } else if( xmid > xt ) {
                     if( ihi == imid ) {
                        if( ipass == 0 ) {
                           jpoly = skey[ ilo ];
                           xmid = Poly_xp[ jpoly ][ 0 ];
                        } else {
                           jpoly = ekey[ ilo ];
                           xmid = Poly_xp[ jpoly ][ Poly_np[ jpoly ] - 1 ];
                        }
                        if( !astEQUALS( xmid, xt, 1.0E8 ) ) jpoly = -1;
                        ikey = ilo;
                        break;
                     }
                     ihi = imid;
                  } else {
                     if( ilo == imid ) {
                        if( ipass == 0 ) {
                           jpoly = skey[ ihi ];
                           xmid = Poly_xp[ jpoly ][ 0 ];
                        } else {
                           jpoly = ekey[ ihi ];
                           xmid = Poly_xp[ jpoly ][ Poly_np[ jpoly ] - 1 ];
                        }
                        if( !astEQUALS( xmid, xt, 1.0E8 ) ) jpoly = -1;
                        ikey = ihi;
                        break;
                     }
                     ilo = imid;
                  }
               }

/* If found, there may be more than one such polyline. So we now search
   for a polyline that also has the y value of the concatenation point. */
               if( jpoly != -1 ) {

/* If the polyline found above starts (or ends) at the same Y value as the
   concatenation point, then we have found the required polyline. */
                  if( ipass == 0 ) {
                     ymid = Poly_yp[ jpoly ][ 0 ];
                  } else {
                     ymid = Poly_yp[ jpoly ][ Poly_np[ jpoly ] - 1 ];
                  }
                  if( astEQUALS( ymid, yt, 1.0E8 ) && !drawn[ jpoly ] ) break;
                  jpoly = -1;

/* Otherwise, search down the list, starting at the polyline found above. */
                  if( imid > 0 ) {
                     for( ikey = imid - 1; ikey >= 0; ikey-- ) {
                        if( ipass == 0 ) {
                           kpoly = skey[ ikey ];
                           xmid = Poly_xp[ kpoly ][ 0 ];
                           ymid = Poly_yp[ kpoly ][ 0 ];
                        } else {
                           kpoly = ekey[ ikey ];
                           xmid = Poly_xp[ kpoly ][ Poly_np[ kpoly ] - 1 ];
                           ymid = Poly_yp[ kpoly ][ Poly_np[ kpoly ] - 1 ];
                        }
                        if( astEQUALS( xmid, xt, 1.0E8 ) ) {
                           if( astEQUALS( ymid, yt, 1.0E8 ) && !drawn[ kpoly ] ) {
                              jpoly = kpoly;
                              break;
                           }
                        } else {
                           break;
                        }
                     }
                     if( jpoly != -1 ) break;
                  }

/* Now search up the list, starting at the polyline found above. */
                  if( imid < Poly_npoly - 1 ) {
                     for( ikey = imid + 1; ikey < Poly_npoly; ikey++ ) {
                        if( ipass == 0 ) {
                           kpoly = skey[ ikey ];
                           xmid = Poly_xp[ kpoly ][ 0 ];
                           ymid = Poly_yp[ kpoly ][ 0 ];
                        } else {
                           kpoly = ekey[ ikey ];
                           xmid = Poly_xp[ kpoly ][ Poly_np[ kpoly ] - 1 ];
                           ymid = Poly_yp[ kpoly ][ Poly_np[ kpoly ] - 1 ];
                        }
                        if( astEQUALS( xmid, xt, 1.0E8 ) ) {
                           if( astEQUALS( ymid, yt, 1.0E8 ) && !drawn[ kpoly ] ) {
                              jpoly = kpoly;
                              break;
                           }
                        } else {
                           break;
                        }
                     }
                     if( jpoly != -1 ) break;
                  }
               }
            }

/* If a polyline was found that can be combined with the total polyline,
   increment the total number of points in the total polyline, add it to
   the list, and update the concatenation point. Note, we can omit the
   start or end point of the new polyline since it will already be
   present in the total polyline, hence the " - 1 " below. */
            if( ipass < 2 ) {
               ipoint = Poly_np[ jpoly ] - 1;

               if( ipass == 0 ) {
                  polylist[ npoly++ ] = jpoly;
                  xt = Poly_xp[ jpoly ][ ipoint ];
                  yt = Poly_yp[ jpoly ][ ipoint ];
               } else {
                  polylist[ npoly++ ] = -jpoly;
                  xt = Poly_xp[ jpoly ][ 0 ];
                  yt = Poly_yp[ jpoly ][ 0 ];
               }

               polylen += ipoint;

/* Indicate the polyline has been drawn. */
               drawn[ jpoly ] = 1;

/* If we cannot find any polyline that starts or ends at the
   concatenation point, then we have completed the total polyline. So break
   out of the loop, and move on to draw the total polyline. */
            } else {
               break;
            }
         }

/* If a single polyline is to be drawn, just draw it. */
         if( npoly == 1 ) {
            jpoly = polylist[ 0 ];
            GLine( this, Poly_np[ jpoly ], Poly_xp[ jpoly ],
                   Poly_yp[ jpoly ], method, class, status );

/* If more than one polyline is to be drawn, ensure we have arrays that
   are large enough to hold all the vertices in the combined polyline. */
         } else {
            xnew = astRealloc( xnew, polylen*sizeof( float ) );
            ynew = astRealloc( ynew, polylen*sizeof( float ) );
            if( astOK ) {

/* Loop round all the polylines that are to be combined to form the total
   polyline, and copy all the vertex coordinates into the above arrays. */
               xp1 = xnew;
               yp1 = ynew;
               for( ipoly = 0; ipoly < npoly; ipoly++ ) {

/* Index of the next polyline to include in the total polyline. */
                  jpoly = polylist[ ipoly ];

/* The jpoly value is positive if the polylline is to be inclued in its
   original direction. */
                  if( jpoly >= 0 ) {

/* Use the whole of the first polyline. */
                     if( ipoly == 0 ) {
                        np =  Poly_np[ jpoly ];
                        xp2 = Poly_xp[ jpoly ];
                        yp2 = Poly_yp[ jpoly ];

/* Omit eh first point of subsequent polylines since it will be the same
   as the last pointy already in the total polyline. */
                     } else {
                        np =  Poly_np[ jpoly ] - 1;
                        xp2 = Poly_xp[ jpoly ] + 1;
                        yp2 = Poly_yp[ jpoly ] + 1;
                     }

/* Copy the vertex values in their original order, and update the
   pointers to the next element of the total polyline. */
                     memcpy( xp1, xp2, np*sizeof(float) );
                     memcpy( yp1, yp2, np*sizeof(float) );
                     xp1 +=  np;
                     yp1 +=  np;

/* The jpoly value is negative if the polyline is to be included in its
   reversed direction. */
                  } else {
                     jpoly = -jpoly;

/* Get the number of points to copy. Omit the last point if this is not
   the first polyline, since it is already in the total polyline. */
                     if( ipoly == 0 ) {
                        np =  Poly_np[ jpoly ];
                     } else {
                        np =  Poly_np[ jpoly ] - 1;
                     }

/* Copy the individual values in reversed order. */
                     xp2 = Poly_xp[ jpoly ] + np - 1;
                     yp2 = Poly_yp[ jpoly ] + np - 1;
                     for( ipoint = 0; ipoint < np; ipoint++ ) {
                        *(xp1++) = *(xp2--);
                        *(yp1++) = *(yp2--);
                     }
                  }
               }

/* And finally, draw the total polyline. */
               GLine( this, polylen, xnew, ynew, method, class, status );
            }
         }
      }

/*  Free all the individual polylines. */
      for( ipoly = 0; ipoly < Poly_npoly; ipoly++ ) {
         Poly_xp[ ipoly ] = astFree( Poly_xp[ ipoly ] );
         Poly_yp[ ipoly ] = astFree( Poly_yp[ ipoly ] );
         Poly_np[ ipoly ] = 0;
      }

/* Free other resources. */
      polylist = astFree( polylist );
      drawn = astFree( drawn );
      xnew = astFree( xnew );
      ynew = astFree( ynew );
      skey = astFree( skey );
      ekey = astFree( ekey );
   }

/* Indicate that all polylines have been sent to the graphics system. */
   Poly_npoly = 0;
}

static int Fpoly_ecmp( const void *a, const void *b ){
/*
*  Name:
*     Fpoly_ecmp

*  Purpose:
*     Compare two polylines ending X position

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Fpoly_ecmp( const void *a, const void *b )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function is designed to be used as a comparison function with
*     the "qsort" function. It is used in function Fpoly.
*
*     If orders the two polylines on the basis of the X coordinate at
*     their ends.

*  Parameters:
*     a
*       Pointer to an int holding the index of the first polyline.
*     b
*       Pointer to an int holding the index of the second polyline.

*  Returned Value:
*     -1 if the first polyline ends at a lower X than the second.
*     +1 if the first polyline ends at a higher X than the second.
*     0 if the two polylines end at the same X.

*/

/* Local Variables: */
   float xa;               /* X at end of first polyline */
   float xb;               /* X at end of second polyline */
   int result = 0;         /* Returned value */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Get the x coord at the end of the two polylines. */
   xa = Poly_xp[ *( (int *) a) ][ Poly_np[ *( (int *) a) ] - 1 ];
   xb = Poly_xp[ *( (int *) b) ][ Poly_np[ *( (int *) b) ] - 1 ];

/* Compare them. */
   if( xa < xb ) {
      result = -1;
   } else if( xa > xb ){
      result = 1;
   }

   return result;
}

static int Fpoly_scmp( const void *a, const void *b ){
/*
*  Name:
*     Fpoly_scmp

*  Purpose:
*     Compare two polylines starting X position

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Fpoly_scmp( const void *a, const void *b )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function is designed to be used as a comparison function with
*     the "qsort" function. It is used in function Fpoly.
*
*     If orders the two polylines on the basis of the X coordinate at
*     their starts.

*  Parameters:
*     a
*       Pointer to an int holding the index of the first polyline.
*     b
*       Pointer to an int holding the index of the second polyline.

*  Returned Value:
*     -1 if the first polyline starts at a lower X than the second.
*     +1 if the first polyline starts at a higher X than the second.
*     0 if the two polylines starts at the same X.

*/

/* Local Variables: */
   float xa;               /* X at start of first polyline */
   float xb;               /* X at start of second polyline */
   int result = 0;         /* Returned value */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Get the x coord at the start of the two polylines. */
   xa = Poly_xp[ *( (int *) a) ][ 0 ];
   xb = Poly_xp[ *( (int *) b) ][ 0 ];

/* Compare them. */
   if( xa < xb ) {
      result = -1;
   } else if( xa > xb ){
      result = 1;
   }

   return result;
}

static AstFrameSet *Fset2D( AstFrameSet *fset, int ifrm, int *status ) {
/*
*  Name:
*     Fset2D

*  Purpose:
*     Create a FrameSet with no more than 2 dimensions for a given Frame.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*      AstFrameSet *Fset2D( AstFrameSet *fset, int ifrm, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function checks a specified Frame in the supplied FrameSet.
*     If the Frame has more than 2 dimensions, a new Frame is added to
*     the FrameSet containing just the first two axes of the specified
*     Frame. A PermMap is used to connect this Frame to the specified
*     Frame, which supplied bad values for any missing axes. If the
*     specified Frame is the base Frame in the supplied FrameSet, then the
*     new Frame becomes the base Frame in the returned FrameSet. Like-wise,
*     if the specified Frame is the current Frame, then the new Frame
*     will be the current Frame in the returned FrameSet.
*
*     If the specified Frame does not have more than 2 axes, then a clone
*     of the FrameSet pointer is returned, otherwise the returned pointer
*     points to a copy of the supplied FrameSet with the new 2-D Frame
*     added.

*  Parameters:
*     fset
*        Pointer to the FrameSet.
*     ifrm
*        The index of the Frame to check. This should be AST__BASE or
*        AST_CURRENT.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a FrameSet in which the Frame with index given by ifrm
*     has no more than 2 axes.
*/

/* Local Variables: */
   AstFrame *frm;
   AstFrame *newfrm;
   AstFrameSet *ret;
   AstPermMap *map;
   double zero;
   int *inperm;
   int axes[2];
   int i;
   int ic;
   int nax;

/* Check the inherited status. */
   if( !astOK ) return NULL;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   map = NULL;

/* Get a pointer to the requested Frame in the supplied FrameSet. */
   frm = astGetFrame( fset, ifrm );

/* See how many dimensions the specified Frame of the supplied FrameSet
   has. */
   nax = astGetNaxes( frm );

/* If it is more than 2-dimensionbal, create a 2D Frame by picking
   axes 1 and 2 from the original Frame. */
   if( nax > 2 ) {
      axes[ 0 ] = 0;
      axes[ 1 ] = 1;
      newfrm = astPickAxes( frm, 2, axes, NULL );

/* Create a PermMap to describe the mapping between the two Frames.
   Use zero as the value for unknown axes (the optional mapping which
   can be returned by astPickAxes uses AST__BAD for unknown axes). */
      inperm = (int *) astMalloc( sizeof(int)*(size_t) nax );
      if( astOK ){
         inperm[ 0 ] = 0;
         inperm[ 1 ] = 1;
         for( i = 2; i < nax; i++ ) inperm[ i ] = -1;
         zero = 0.0;
         map = astPermMap( nax, inperm, 2, axes, &zero, "", status );
         inperm = (int *) astFree( (void *) inperm );
      }

/* Get a copy of the supplied FrameSet. */
      ret = astCopy( fset );

/* Add the new Frame to the FrameSet (it becomes the current Frame). */
      ic = astGetCurrent( ret );
      astAddFrame( ret, ifrm, map, newfrm );
      newfrm = astAnnul( newfrm );

/* If the new Frame was derived from the base frame, set the new base
   Frame, and re-instate the original current Frame */
      if( ifrm == AST__BASE ){
         astSetBase( ret, astGetCurrent( ret ) );
         astSetCurrent( ret, ic );
      }

/* If the specified Frame in the supplied FrameSet is 2-dimensional, just
   return a clone of it. */
   } else {
      ret = astClone( fset );
   }

/* Annul the pointer to the original Frame. */
   frm = astAnnul( frm );

   return ret;

}

static int FullForm( const char *list, const char *test, const char *text,
                     const char *method, const char *class, int *status ){
/*
*  Name:
*     FullForm

*  Purpose:
*     Identify the full form of an option string.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int FullForm( const char *list, const char *test, const char *text,
*                   const char *method, const char *class, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function identifies a supplied test option within a supplied
*     list of valid options, and returns the index of the option within
*     the list. The test option may be abbreviated, and case is
*     insignificant.

*  Parameters:
*     list
*        A list of space separated option strings.
*     test
*        A candidate option string.
*     text
*        A string giving the context in which the supplied test option
*        was supplied. For instance, this may be an attribute setting string.
*        This is only for use in constructing error messages.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The index of the identified option within the supplied list, starting
*     at zero.

*  Notes:
*     -  A value of -1 is returned if an error has already occurred, or
*     if this function should fail for any reason (for instance if the
*     supplied option is not uniquely specified in the supplied list).

*/

/* Local Variables: */
   char *option;           /* Pointer to a copy of the next option */
   const char *p;          /* Pointer to the start of the next word */
   int i;                  /* Current option index */
   int len;                /* Length of supplied option */
   int nmatch;             /* Number of matching options */
   int ret;                /* The returned index */

/* Initialise the answer to indicate that the option has not been
   uniquely identified. */
   ret = -1;

/* Check global status. */
   if( !astOK ) return ret;

/* Save the number of characters in the supplied test option (excluding
   trailing spaces). */
   len = ChrLen( test, status );

/* Compare the supplied test option against each of the known options in
   turn. Count the number of matches. */
   nmatch = 0;
   p = list;
   option = FindWord( NULL, " ", &p, status );
   i = 0;
   while( option ){

/* If the test string and the current option are identical (including
   length). use the current option. */

/* If every character in the supplied label matches the corresponding
   character in the current test label we have a match. Increment the
   number of matches and save the current item index. If the test string
   and the current option are identical (including length), use the
   current option. */

      if( !Ustrncmp( test, option, len, status ) ) {
         ret = i;
         if( ChrLen( option, status ) == len ) {
            nmatch = 1;
            option = astFree( option );
            break;
         } else {
            nmatch++;
         }
      }

/* Get a pointer to the next option. */
      option = FindWord( option, " ", &p, status );
      i++;
   }

/* Report an error if no match was found, and return -1. */
   if( !nmatch ){
      astError( AST__OPT, "%s(%s): Option '%.*s' is unknown in '%.*s'.", status,
                method, class, len, test, ChrLen( text, status ), text );
      ret = -1;

/* Report an error if the label was ambiguous, and return -1. */
   } else if( nmatch > 1 ){
      astError( AST__OPT, "%s(%s): Option '%.*s' is ambiguous in '%.*s'.", status,
                method, class, len, test, ChrLen( text, status ), text );
      ret = -1;
   }

/* Return the answer. */
   return ret;
}

static void GAttr( AstPlot *this, int attr, double value, double *old_value,
                   int prim, const char *method, const char *class, int *status ) {
/*
*
*  Name:
*     GAttr

*  Purpose:
*     Call the GAttr Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GAttr( AstPlot *this, int attr, double value, double *old_value,
*                 int prim, const char *method, const char *class, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GAttr grf function to enquire or set a
*     graphics attribute value. It either calls the version registered using
*     astGrfSet, or the version in the linked grf module. The linked version
*     is used if the Grf attribute is zero, or if no function has been
*     registered for GAttr using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     attr
*        An integer value identifying the required attribute. The
*        following symbolic values are defined in grf.h:
*
*           GRF__STYLE  - Line style.
*           GRF__WIDTH  - Line width.
*           GRF__SIZE   - Character and marker size scale factor.
*           GRF__FONT   - Character font.
*           GRF__COLOUR - Colour index.
*     value
*        A new value to store for the attribute. If this is AST__BAD
*        no value is stored.
*     old_value
*        A pointer to a double in which to return the attribute value.
*        If this is NULL, no value is returned.
*     prim
*        The sort of graphics primitive to be drawn with the new attribute.
*        Identified by the following values defined in grf.h:
*           GRF__LINE
*           GRF__MARK
*           GRF__TEXT
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. Also return if there is nothing to do. */
   if ( !astOK || ( !old_value && value == AST__BAD ) ) return;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GATTR ] ) {
      grf_status = ( *( this->GAttr ) )( this, attr, value, old_value, prim, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGAttr( attr, value, old_value, prim );
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGAttr. ", status, method,
                class );
   }

}

static AstKeyMap *GetGrfContext( AstPlot *this, int *status ){
/*
*++
*  Name:
c     astGetGrfContext
f     AST_GETGRFCONTEXT

*  Purpose:
*     Return the KeyMap that describes a Plot's graphics context.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     AstKeyMap *astGetGrfContext( AstPlot *this )
f     RESULT = AST_GETGRFCONTEXT( THIS, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function
f     This routine
*     returns a reference to a KeyMap that will be passed to any drawing
c     functions registered using astGrfSet.
f     routines registered using AST_GRFSET.
*     This KeyMap can be used by an application to pass information to
c     the drawing functions
f     the drawing routines
*     about the context in which they are being called. The contents of
*     the KeyMap are never accessed byt the Plot class itself.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astGetGrfContext()
f     AST_GETGRFCONTEXT = INTEGER
*        A pointer to the graphics context KeyMap. The returned pointer
*        should be annulled when it is no longer needed.

*--
*/

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* Ensure that a grfcon KeyMap exists. */
   (void) astGrfConID(this);

/* Return a cloned pointer to the KeyMap. */
   return astClone( this->grfcontext );
}

AstKeyMap *astGrfConID_( AstPlot *this, int *status ) {
/*
*+
*
*  Name:
*     astGrfConID

*  Purpose:
*     Ensure a GrfContext KeyMap exists and return an ID for it.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     AstKeyMap *astGrfConID( AstPlot *this )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function creates a GrfContext KeyMap if the Plot does not
*     currently have one, and returns an ID for it.

*  Parameters:
*     this
*        The Plot.

*  Returned Value:
*     ID for the GrfContext KeyMap.

*-
*/
   if( !this->grfcontext ) {
      this->grfcontext = astKeyMap("", status );
      this->grfcontextID = astMakeId( astClone( this->grfcontext ) );
      astExempt( this->grfcontextID );
   }
   return this->grfcontextID;
}

static void GScales( AstPlot *this, float *alpha, float *beta,
                      const char *method, const char *class, int *status ) {
/*
*
*  Name:
*     GScales

*  Purpose:
*     Call the GScales Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GScales( AstPlot *this, float *alpha, float *beta,
*                    const char *method, const char *class, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GScales grf function, either calling the
*     version registered using astGrfSet, or the version in the linked grf
*     module. The linked version is used if the Grf attribute is zero, or if
*     no function has been registered for GScales using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     alpha
*        A pointer to the location at which to return the scale for the
*        X axis (i.e. Xnorm = alpha*Xworld).
*     beta
*        A pointer to the location at which to return the scale for the
*        Y axis (i.e. Ynorm = beta*Yworld).
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* if we already have the required values, return them. */
   if( Grf_alpha != 0.0 && Grf_beta != 0.0 ) {
      if( alpha ) *alpha = Grf_alpha;
      if( beta ) *beta = Grf_beta;
      return;
   }

/* Check that the grf mdoule can give us scales information. */
   if( GCap( this, GRF__SCALES, 1, status ) ) {

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
      LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
      if( astGetGrf( this ) && this->grffun[ AST__GSCALES ] ) {
         grf_status = ( *( this->GScales ) )( this, &Grf_alpha, &Grf_beta, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
      } else {
         grf_status = astGScales( &Grf_alpha, &Grf_beta );
      }

/* Allow the next thread to proceed. */
      UNLOCK_MUTEX2;

/* Check neither value is zero. */
      if( grf_status && ( Grf_alpha == 0.0 || Grf_beta == 0.0 ) ) {
         astError( AST__GRFER, "astGScales: Returned axis scales are %g and %g "
                   "but zero is illegal!", status, Grf_alpha, Grf_beta );
         grf_status = 0;
      }

/* Report an error if anything went wrong, and return safe values. */
      if( !grf_status ) {
         astError( AST__GRFER, "%s(%s): Graphics error in astGScales. ", status, method,
                   class );
         Grf_alpha = 1.0;
         Grf_beta = 1.0;
      }

/* If the grf module is not capable of giving us scale information, then
   just assume the the axes are equally scaled, except for any axis reversal
   indicated in the supplied Plot. */
   } else {
      Grf_alpha = ( this->xrev ) ? -1.0 : 1.0;
      Grf_beta = ( this->yrev ) ? -1.0 : 1.0;
   }

/* Store them for future use. */
   if( alpha ) *alpha = Grf_alpha;
   if( beta ) *beta = Grf_beta;
}

static int GCap( AstPlot *this, int cap, int value, int *status ){
/*
*
*  Name:
*     GCap

*  Purpose:
*     Call the GCap Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GCap( AstPlot *this, int cap, int value, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GCap grf function to inquire a capability
*     of the grf module, either calling the version registered using
*     astGrfSet, or the version in the linked grf module. The linked
*     version is used if the Grf attribute is zero, or if no function
*     has been registered for GCap using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     cap
*        The capability to be inquired aboue.
*     value
*        The value to assign to the capability.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Non-zero if the grf module is capabale of performing the action
*     requested by "cap".

*/

/* Local Variables: */
   int result;          /* Value retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GCAP ] ) {
      result = ( *( this->GCap ) )( this, cap, value, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      result = astGCap( cap, value );

   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Return the result. */
   return result;
}

static void GenCurve( AstPlot *this, AstMapping *map, int *status ){
/*
*++
*  Name:
c     astGenCurve
f     AST_GENCURVE

*  Purpose:
*     Draw a generalized curve.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astGenCurve( AstPlot *this, astMapping *map )
f     CALL AST_GENCURVE( THIS, MAP )

*  Class Membership:
*     Plot method.

*  Description:
c     This function draws a general user-defined curve defined by the
f     This routine draws a general user-defined curve defined by the
*     supplied Mapping. Note that the curve is transformed into graphical
*     coordinate space for plotting, so that a straight line in
*     physical coordinates may result in a curved line being drawn if
*     the Mapping involved is non-linear. Any discontinuities in the
*     Mapping between physical and graphical coordinates are
c     catered for, as is any clipping established using astClip.
f     catered for, as is any clipping established using AST_CLIP.
*
c     If you need to draw simple straight lines (geodesics), astCurve
c     or astPolyCurve will usually be easier to use and faster.
f     If you need to draw simple straight lines (geodesics), AST_CURVE
f     or AST_POLYCURVE will usually be easier to use and faster.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     map
f     MAP = INTEGER (Given)
*        Pointer to a Mapping. This Mapping should have 1 input
*        coordinate representing offset along the required curve,
*        normalized so that the start of the curve is at offset 0.0,
*        and the end of the curve is at offset 1.0. Note, this offset
*        does not need to be linearly related to distance along the curve.
*        The number of output coordinates should equal the number of axes
*        in the current Frame of the Plot. The Mapping should map a
*        specified offset along the curve, into the corresponding
*        coordinates in the current Frame of the Plot. The inverse
*        transformation need not be defined.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - An error results if the base Frame of the Plot is not 2-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*--
*/
/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   double d[ CRV_NPNT ];   /* Offsets to evenly spaced points along curve */
   double tol;             /* Absolute tolerance value */
   double x[ CRV_NPNT ];   /* X coords at evenly spaced points along curve */
   double y[ CRV_NPNT ];   /* Y coords at evenly spaced points along curve */
   int i;                  /* Loop count */
   int naxes;              /* No. of axes in the base Frame */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astGenCurve";
   class = astGetClass( this );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Only proceed if there has been no error. */
   if( astOK ){

/* Initialise the bounding box for primitives produced by this call. */
      if( !Boxp_freeze ) {
         Boxp_lbnd[ 0 ] = FLT_MAX;
         Boxp_lbnd[ 1 ] = FLT_MAX;
         Boxp_ubnd[ 0 ] = FLT_MIN;
         Boxp_ubnd[ 1 ] = FLT_MIN;
      }

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
      RESET_GRF;

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
      astGrfAttrs( this, AST__CURVE_ID, 1, GRF__LINE, method, class );

/* Ensure the globals holding the scaling from graphics coords to equally
   scaled coords are available. */
      GScales( this, NULL, NULL, method, class, status );

/* Set up the externals used to communicate with the Map4 function... */
      Map4_ncoord = astGetNout( this );
      Map4_plot = this;
      Map4_map = astGetMapping( this, AST__BASE, AST__CURRENT );
      Map4_umap = map;

/* Convert the tolerance from relative to absolute graphics coordinates. */
      tol = astGetTol( this )*astMAX( this->xhi - this->xlo,
                                      this->yhi - this->ylo );

/* Now set up the external variables used by the Crv and CrvLine function. */
      Crv_scerr = ( astGetLogPlot( this, 0 ) ||
                    astGetLogPlot( this, 1 ) ) ? 100.0 : 1.5;
      Crv_ux0 = AST__BAD;
      Crv_tol = tol;
      Crv_limit = 0.5*tol*tol;
      Crv_map = Map4;
      Crv_ink = 1;
      Crv_xlo = this->xlo;
      Crv_xhi = this->xhi;
      Crv_ylo = this->ylo;
      Crv_yhi = this->yhi;
      Crv_out = 1;
      Crv_xbrk = Curve_data.xbrk;
      Crv_ybrk = Curve_data.ybrk;
      Crv_vxbrk = Curve_data.vxbrk;
      Crv_vybrk = Curve_data.vybrk;
      Crv_clip = astGetClip( this ) & 1;

/* Set up a list of points spread evenly over the curve. */
      for( i = 0; i < CRV_NPNT; i++ ){
        d[ i ] = ( (double) i)/( (double) CRV_NSEG );
      }

/* Map these points into graphics coordinates. */
      Map4( CRV_NPNT, d, x, y, method, class, status GLOBALS_NAME );

/* Use Crv and Map4 to draw the curve. */
      Crv( this, d, x, y, 0, NULL, NULL, method, class, status );

/* End the current poly line. */
      Opoly( this, status );

/* Tidy up the static data used by Map4. */
      Map4( 0, NULL, NULL, NULL, method, class, status GLOBALS_NAME );

/* If no part of the curve could be drawn, set the number of breaks and the
   length of the drawn curve to zero. */
      if( Crv_out ) {
         Crv_nbrk = 0;
         Crv_len = 0.0F;

/* Otherwise, add an extra break to the returned structure at the position of
   the last point to be plotted. */
      } else {
         Crv_nbrk++;
         if( Crv_nbrk > AST__PLOT_CRV_MXBRK ){
            astError( AST__CVBRK, "%s(%s): Number of breaks in curve "
                      "exceeds %d.", status, method, class, AST__PLOT_CRV_MXBRK );
         } else {
            *(Crv_xbrk++) = (float) Crv_xl;
            *(Crv_ybrk++) = (float) Crv_yl;
            *(Crv_vxbrk++) = (float) -Crv_vxl;
            *(Crv_vybrk++) = (float) -Crv_vyl;
         }
      }

/* Store extra information about the curve in the returned structure, and
   purge any zero length sections. */
      Curve_data.length = Crv_len;
      Curve_data.out = Crv_out;
      Curve_data.nbrk = Crv_nbrk;
      PurgeCdata( &Curve_data, status );

/* Annul the Mapping. */
      Map4_map = astAnnul( Map4_map );

/* Ensure all lines are flushed to the graphics system. */
      Fpoly( this, method, class, status );

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, AST__CURVE_ID, 0, GRF__LINE, method, class );
   }

/* Return. */
   return;

}

static int GetLabelUnits( AstPlot *this, int axis, int *status ) {
/*
*  Name:
*     GetLabelUnits

*  Purpose:
*     Return the value of the LabelUnits attribute for a Plot axis.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GetLabelUnits( AstPlot *this, int axis, int *status )

*  Class Membership:
*     Plot method.

*  Description:
*     This function returns the value of the LabelUnits attribute for a
*     Plot axis, supplying a suitable default if not set.

*  Parameters:
*     this
*        The Plot.
*     axis
*        The axis index (zero based).
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The attribute value.

*/

/* Local Variables: */
   AstFrame *fr;           /* The current Frame in the Plot */
   AstFrame *primframe;    /* The primary Frame holding the requested axis */
   AstSystemType system;   /* The SkyFrame System attribute */
   int primaxis;           /* Index of requested axis in the primary frame */
   int ret;                /* The returned value */

/* Initialise. */
   ret = 0;

/* Check global status. */
   if( !astOK ) return ret;

/* If a value has been set, return it. */
   ret = this->labelunits[ axis ];

/* If no value has been set, find a default. */
   if( ret == -1 ) {

/* Assume "no" for any SkyAxis axes within the current frame of the Plot,
   and "yes" for other axes. Get a pointer to the current Frame of the
   Plot. */
      fr = astGetFrame( this, AST__CURRENT );

/* The current Frame may be a CmpFrame. So find the primary Frame containing
   the requested axis. The primary Frame is guaranteed not to be a CmpFrame. */
      astPrimaryFrame( fr, axis, &primframe, &primaxis );

/* If the primary Frame is a SkyFrame representing ICRS, equatorial, ecliptic,
   galactic or supergalactic coords, use a default of "no" for LabelUnits.
   Otherwise use a default of "yes". */
      ret = 1;
      if( IsASkyFrame( (AstObject *) primframe, status ) ) {
        system = astGetSystem( primframe );
        if( system == AST__ICRS ||
            system == AST__FK4 ||
            system == AST__FK4_NO_E ||
            system == AST__FK5 ||
            system == AST__GAPPT ||
            system == AST__ECLIPTIC ||
            system == AST__GALACTIC ||
            system == AST__SUPERGALACTIC ) ret = 0;
      }

/* Annul the frame pointers. */
      primframe = astAnnul( primframe );
      fr = astAnnul( fr );
   }

/* Return the answer. */
   return ret;
}

static void GBBuf( AstPlot *this, const char *method,
                   const char *class, int *status ) {
/*
*
*  Name:
*     GBBuf

*  Purpose:
*     Call the GBBuf Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GBBuf( AstPlot *this, const char *method,
*                  const char *class, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GBBuf grf function to begin a new graphics
*     context, either calling the version registered using astGrfSet, or
*     the version in the linked grf module. The linked version is used
*     if the Grf attribute is zero, or if no function has been registered
*     for GBBuf using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GBBUF ] ) {
      grf_status = ( *( this->GBBuf ) )( this, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGBBuf();
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGBBuf. ", status, method,
                class );
   }

}

static void GEBuf( AstPlot *this, const char *method,
                   const char *class, int *status ) {
/*
*
*  Name:
*     GEBuf

*  Purpose:
*     Call the GEBuf Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GEBuf( AstPlot *this, const char *method,
*                  const char *class, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GEBuf grf function to end the current graphics
*     context, either calling the version registered using astGrfSet, or
*     the version in the linked grf module. The linked version is used
*     if the Grf attribute is zero, or if no function has been registered
*     for GEBuf using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GEBUF ] ) {
      grf_status = ( *( this->GEBuf ) )( this, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGEBuf();
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGEBuf. ", status, method,
                class );
   }

}

static void GFlush( AstPlot *this, const char *method,
                   const char *class, int *status ) {
/*
*
*  Name:
*     GFlush

*  Purpose:
*     Call the Gflush Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GFlush( AstPlot *this, const char *method,
*                  const char *class, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the Gflush grf function to flush graphics, either
*     calling the version registered using astGrfSet, or the version in the
*     linked grf module. The linked version is used if the Grf attribute
*     is zero, or if no function has been registered for Gflush using
*     astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GFLUSH ] ) {
      grf_status = ( *( this->GFlush ) )( this, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGFlush();
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGFlush. ", status, method,
                class );
   }

}

static void GLine( AstPlot *this, int n, const float *x,
                   const float *y, const char *method,
                   const char *class, int *status ) {
/*
*
*  Name:
*     GLine

*  Purpose:
*     Call the Gline Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GLine( AstPlot *this, int n, const float *x,
*                 const float *y, const char *method,
*                 const char *class, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the Gline grf function to draw a polyline, either
*     calling the version registered using astGrfSet, or the version in the
*     linked grf module. The linked version is used if the Grf attribute
*     is zero, or if no function has been registered for Gline using
*     astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     n
*        The number of positions to be joined together.
*     x
*        A pointer to an array holding the "n" x values.
*     y
*        A pointer to an array holding the "n" y values.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS   /* Pointer to thread-specific global data */
   int i;               /* Loop count */
   int grf_status;      /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Do not draw anything if we are using "invisible ink". */
   if( astGetInvisible( this ) ) {
      grf_status = 1;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   } else if( astGetGrf( this ) && this->grffun[ AST__GLINE ] ) {
      grf_status = ( *( this->GLine ) )( this, n, x, y, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGLine( n, x, y );
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGLine. ", status, method,
                class );

/* Otherwise, update the box containing all drawn graphics primitives. */
   } else if( !Boxp_freeze ){
      for( i = 0; i < n; i++ ) {
         Boxp_lbnd[ 0 ] = astMIN( x[ i ], Boxp_lbnd[ 0 ] );
         Boxp_ubnd[ 0 ] = astMAX( x[ i ], Boxp_ubnd[ 0 ] );
         Boxp_lbnd[ 1 ] = astMIN( y[ i ], Boxp_lbnd[ 1 ] );
         Boxp_ubnd[ 1 ] = astMAX( y[ i ], Boxp_ubnd[ 1 ] );
      }
   }

}

static void GMark( AstPlot *this, int n, const float *x,
                   const float *y, int type, const char *method,
                   const char *class, int *status ) {
/*
*
*  Name:
*     GMark

*  Purpose:
*     Call the GMark Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GMark( AstPlot *this, int n, const float *x,
*                 const float *y, int type, const char *method,
*                 const char *class, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GMark grf function to draw markers, either
*     calling the version registered using astGrfSet, or the version in the
*     linked grf module. The linked version is used if the Grf attribute
*     is zero, or if no function has been registered for GMark using
*     astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     n
*        The number of positions to be joined together.
*     x
*        A pointer to an array holding the "n" x values.
*     y
*        A pointer to an array holding the "n" y values.
*     type
*        An integer which can be used to indicate the type of marker symbol
*        required.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS   /* Pointer to thread-specific global data */
   int i;               /* Loop count */
   int grf_status;      /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Do not draw anything if we are using "invisible ink". */
   if( astGetInvisible( this ) ) {
      grf_status = 1;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   } else if( astGetGrf( this ) && this->grffun[ AST__GMARK ] ) {
      grf_status = ( *( this->GMark ) )( this, n, x, y, type, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGMark( n, x, y, type );
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGMark. ", status, method,
                class );

/* Otherwise, update the box containing all drawn graphics primitives. */
   } else if( !Boxp_freeze ){
      for( i = 0; i < n; i++ ) {
         Boxp_lbnd[ 0 ] = astMIN( x[ i ], Boxp_lbnd[ 0 ] );
         Boxp_ubnd[ 0 ] = astMAX( x[ i ], Boxp_ubnd[ 0 ] );
         Boxp_lbnd[ 1 ] = astMIN( y[ i ], Boxp_lbnd[ 1 ] );
         Boxp_ubnd[ 1 ] = astMAX( y[ i ], Boxp_ubnd[ 1 ] );
      }
   }

}

static void GQch( AstPlot *this, float *chv, float *chh, const char *method,
                  const char *class, int *status ) {
/*
*
*  Name:
*     GQch

*  Purpose:
*     Call the GQch Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GQch( AstPlot *this, float *chv, float *chh, const char *method,
*                const char *class, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GQch grf function, either calling the
*     version registered using astGrfSet, or the version in the linked grf
*     module. The linked version is used if the Grf attribute is zero, or if
*     no function has been registered for GQch using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     chv
*        A pointer to the double which is to receive the height of
*        characters drawn with a vertical baseline . This will be an
*        increment in the X axis.
*     chh
*        A pointer to the double which is to receive the height of
*        characters drawn with a horizontal baseline. This will be an
*        increment in the Y axis.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* if we already have the required values, return them. */
   if( Grf_chh != AST__BAD && Grf_chv != AST__BAD ) {
      *chh = Grf_chh;
      *chv = Grf_chv;
      return;
   }

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GQCH ] ) {
      grf_status = ( *( this->GQch ) )( this, chv, chh, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGQch( chv, chh );
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Check neither value is zero. */
   if( grf_status && ( *chh == 0.0 || *chv == 0.0 ) ) {
      astError( AST__GRFER, "astGQch: Returned text heights are %g and %g "
                "but zero is illegal!", status, *chv, *chh );
      grf_status = 0;
   }

/* Report an error if anything went wrong, and return safe values. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGQch. ", status, method,
                class );
      *chh = 1.0;
      *chv = 1.0;
   }

/* Store them for future use. */
   Grf_chh = *chh;
   Grf_chv = *chv;
}

static void GText( AstPlot *this, const char *text, float x, float y,
                   const char *just, float upx, float upy,
                   const char *method, const char *class, int *status ) {
/*
*
*  Name:
*     GText

*  Purpose:
*     Call the GText Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GText( AstPlot *this, const char *text, float x, float y,
*                 const char *just, float upx, float upy,
*                 const char *method, const char *class, int *status ) {

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GText grf function to draw a text string, either
*     calling the version registered using astGrfSet, or the version in the
*     linked grf module. The linked version is used if the Grf attribute
*     is zero, or if no function has been registered for GText using
*     astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
*     upy
*        The y component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* Do not draw anything if we are using "invisible ink". */
   if( astGetInvisible( this ) ) {
      grf_status = 1;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   } else if( astGetGrf( this ) && this->grffun[ AST__GTEXT ] ) {
      grf_status = ( *( this->GText ) )( this, text, x, y, just, upx, upy, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGText( text, x, y, just, upx, upy );
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGText. ", status, method,
                class );
   }

}

static void GTxExt( AstPlot *this, const char *text, float x, float y,
                    const char *just, float upx, float upy, float *xbn,
                    float *ybn, const char *method, const char *class, int *status ) {
/*
*
*  Name:
*     GTxExt

*  Purpose:
*     Call the GTxExt Grf function.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void GTxExt( AstPlot *this, const char *text, float x, float y,
*                 const char *just, float upx, float upy, float *xbn,
*                 float *ybn, const char *method, const char *class, int *status )

*  Class Membership:
*     Plot private function.

*  Description:
*     This function calls the GTxExt grf function to find the extent
*     of a text string, either calling the version registered using
*     astGrfSet, or the version in the linked grf module. The linked
*     version is used if the Grf attribute is zero, or if no function
*     has been registered for GTxExt using astGrfSet.

*  Parameters:
*     this
*        The Plot.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
*     upy
*        The y component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.
*     xbn
*        An array of 4 elements in which to return the x coordinate of
*        each corner of the bounding box.
*     ybn
*        An array of 4 elements in which to return the y coordinate of
*        each corner of the bounding box.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - The corners are returned in no particular order.

*/

/* Local Variables: */
   int grf_status;          /* Status retruned from Grf function */

/* Check the global error status. */
   if ( !astOK ) return;

/* Since we are about to call an external function which may not be
   thread safe, prevent any other thread from executing the following code
   until the current thread has finished executing it. */
   LOCK_MUTEX2;

/* If the Grf attribute is set to a non-zero value, use the Grf function
   registered using astGrfSet (so long as a function has been supplied).
   This is called via a wrapper which adapts the interface to suit the
   language in which the function is written. */
   if( astGetGrf( this ) && this->grffun[ AST__GTXEXT ] ) {
      grf_status = ( *( this->GTxExt ) )( this, text, x, y, just, upx, upy,
                                          xbn, ybn, status );

/* Otherwise, use the function in the external Grf module, selected at
   link-time using ast_link options.*/
   } else {
      grf_status = astGTxExt( text, x, y, just, upx, upy, xbn, ybn );
   }

/* Allow the next thread to proceed. */
   UNLOCK_MUTEX2;

/* Report an error if anything went wrong. */
   if( !grf_status ) {
      astError( AST__GRFER, "%s(%s): Graphics error in astGTxExt. ", status, method,
                class );
   }
}

static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     GetAttrib

*  Purpose:
*     Get the value of a specified attribute for a Plot.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Plot member function (over-rides the protected astGetAttrib
*     method inherited from the FrameSet class).

*  Description:
*     This function returns a pointer to the value of a specified
*     attribute for a Plot, formatted as a character string.
*
*     The value returned is the value which would actually be used if
*     astGrid was called with the current set of attribute values. This
*     may not always be the same as the value set by the user. For
*     instance, if Labelling is set to "exterior" by the user, it may not
*     be possible to produce exterior labels, in which case interior labels
*     will be produced. If this function is used to get the value of
*     Labelling in this situation, then the value actually used (i.e.
*     interior) will be returned instead of the requested value (i.e.
*     exterior).
*
*     Some attributes have dynamic defaults, (i.e. the behaviour if not
*     set depends on the values of other attributes). If the value for
*     such an attribute is enquired using this function, then the dynamic
*     default value actually used will be returned if no value has been
*     set explicitly for the attribute.

*  Parameters:
*     this
*        Pointer to the Plot.
*     attrib
*        Pointer to a null terminated string containing the name of
*        the attribute whose value is required. This name should be in
*        lower case, with all white space removed.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     - Pointer to a null terminated string containing the attribute
*     value.

*  Notes:
*     - The returned string pointer may point at memory allocated
*     within the Plot, or at static memory. The contents of the
*     string may be over-written or the pointer may become invalid
*     following a further invocation of the same function or any
*     modification of the Plot. A copy of the string should
*     therefore be made if necessary.
*     - A NULL pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstPlot *this;                /* Pointer to the Plot structure */
   const char *result;           /* Pointer value to return */
   char label[21];               /* Graphics item label */
   double dval;                  /* Double attribute value */
   int axis;                     /* Axis number */
   int ival;                     /* Int attribute value */
   int len;                      /* Length of attrib string */
   int nc;                       /* No. characters read by astSscanf */

/* Initialise. */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this_object);

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) this_object;

/* Obtain the length of the attrib string. */
   len = strlen( attrib );

/* Indicate that the current bound box should not be changed during the
   execution of this function (this may happen if a grid is drawn to get
   the default value for an attribute such as Labelling). */
   Boxp_freeze = 1;

/* Compare "attrib" with each recognised attribute name in turn,
   obtaining the value of the required attribute. If necessary, write
   the value into "getattrib_buff" as a null terminated string in an appropriate
   format.  Set "result" to point at the result string. */

/* Tol. */
/* ---- */
   if ( !strcmp( attrib, "tol" ) ) {
      dval = astGetTol( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Grid. */
/* ----- */
   } else if ( !strcmp( attrib, "grid" ) ) {
      ival = GetUsedGrid( this, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* TickAll. */
/* -------- */
   } else if ( !strcmp( attrib, "tickall" ) ) {
      ival = astGetTickAll( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* ForceExterior. */
/* -------------- */
   } else if ( !strcmp( attrib, "forceexterior" ) ) {
      ival = astGetForceExterior( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Invisible. */
/* ---------- */
   } else if ( !strcmp( attrib, "invisible" ) ) {
      ival = astGetInvisible( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Border. */
/* ------- */
   } else if ( !strcmp( attrib, "border" ) ) {
      ival = GetUsedBorder( this, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* ClipOp. */
/* ------- */
   } else if ( !strcmp( attrib, "clipop" ) ) {
      ival = astGetClipOp( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Clip. */
/* ----- */
   } else if ( !strcmp( attrib, "clip" ) ) {
      ival = astGetClip( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Grf. */
/* ---- */
   } else if ( !strcmp( attrib, "grf" ) ) {
      ival = astGetGrf( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* DrawTitle. */
/* --------- */
   } else if ( !strcmp( attrib, "drawtitle" ) ) {
      ival = astGetDrawTitle( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Escape. */
/* ------- */
   } else if ( !strcmp( attrib, "escape" ) ) {
      ival = astGetEscape( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LabelAt(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelat(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUsedLabelAt( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Centre(axis). */
/* ------------ */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "centre(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUsedCentre( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Gap. */
/* ---- */
   } else if ( !strcmp( attrib, "gap" ) ) {
      dval = GetUsedGap( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Gap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "gap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUsedGap( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* LogGap. */
/* ---- */
   } else if ( !strcmp( attrib, "loggap" ) ) {
      dval = GetUsedLogGap( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* LogGap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "loggap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUsedLogGap( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* NumLabGap. */
/* -------- */
   } else if ( !strcmp( attrib, "numlabgap" ) ) {
      dval = astGetNumLabGap( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* NumLabGap(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "numlabgap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = astGetNumLabGap( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* TextLabGap. */
/* ----------- */
   } else if ( !strcmp( attrib, "textlabgap" ) ) {
      dval = astGetTextLabGap( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* TextLabGap(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "textlabgap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = astGetTextLabGap( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* LabelUp. */
/* -------- */
   } else if ( !strcmp( attrib, "labelup" ) ) {
      ival = astGetLabelUp( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LabelUp(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelup(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = astGetLabelUp( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LogPlot. */
/* -------- */
   } else if ( !strcmp( attrib, "logplot" ) ) {
      ival = astGetLogPlot( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LogPlot(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "logplot(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = astGetLogPlot( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LogLabel. */
/* -------- */
   } else if ( !strcmp( attrib, "loglabel" ) ) {
      ival = GetUsedLogLabel( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LogLabel(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "loglabel(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUsedLogLabel( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LogTicks. */
/* -------- */
   } else if ( !strcmp( attrib, "logticks" ) ) {
      ival = GetUsedLogTicks( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LogTicks(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "logticks(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUsedLogTicks( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* NumLab. */
/* -------- */
   } else if ( !strcmp( attrib, "numlab" ) ) {
      ival = astGetNumLab( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* NumLab(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "numlab(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = astGetNumLab( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* MinTick. */
/* -------- */
   } else if ( !strcmp( attrib, "mintick" ) ) {
      ival = GetUsedMinTick( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* MinTick(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "mintick(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUsedMinTick( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* TextLab. */
/* ---------- */
   } else if ( !strcmp( attrib, "textlab" ) ) {
      ival = GetUsedTextLab( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* TextLab(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "textlab(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUsedTextLab( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* DrawAxes. */
/* ----------- */
   } else if ( !strcmp( attrib, "drawaxes" ) ) {
      ival = astGetDrawAxes( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* DrawAxes(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "drawaxes(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetDrawAxes( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Abbrev. */
/* ----------- */
   } else if ( !strcmp( attrib, "abbrev" ) ) {
      ival = astGetAbbrev( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Abbrev(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "abbrev(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetAbbrev( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LabelUnits. */
/* ----------- */
   } else if ( !strcmp( attrib, "labelunits" ) ) {
      ival = GetUsedLabelUnits( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* LabelUnits(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelunits(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUsedLabelUnits( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Style. */
/* ------ */
   } else if ( !strcmp( attrib, "style" ) ) {
      ival = GetUseStyle( this, AST__BORDER_ID, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Style(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "style(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUseStyle( this, FullForm( GrfLabels, label, attrib, "astGet", astGetClass( this ), status ), status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Font. */
/* ----- */
   } else if ( !strcmp( attrib, "font" ) ) {
      ival = GetUseFont( this, AST__TEXTLABS_ID, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Font(label). */
/* ------------ */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "font(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUseFont( this, FullForm( GrfLabels, label, attrib, "astGet", astGetClass( this ), status ), status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Colour. */
/* ------- */
   } else if ( !strcmp( attrib, "colour" ) ) {
      ival = GetUseColour( this, AST__TEXTLABS_ID, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Colour(label). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "colour(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUseColour( this, FullForm( GrfLabels, label, attrib, "astGet", astGetClass( this ), status ), status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Color. */
/* ------ */
   } else if ( !strcmp( attrib, "color" ) ) {
      ival = GetUseColour( this, AST__TEXTLABS_ID, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Color(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "color(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUseColour( this, FullForm( GrfLabels, label, attrib, "astGet", astGetClass( this ), status ), status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* Width. */
/* ------ */
   } else if ( !strcmp( attrib, "width" ) ) {
      dval = GetUseWidth( this, AST__BORDER_ID, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }


/* Width(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "width(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUseWidth( this, FullForm( GrfLabels, label, attrib, "astGet", astGetClass( this ), status ), status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Size. */
/* ----- */
   } else if ( !strcmp( attrib, "size" ) ) {
      dval = GetUseSize( this, AST__TEXTLABS_ID, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Size(label). */
/* ------------ */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "size(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUseSize( this, FullForm( GrfLabels, label, attrib, "astGet", astGetClass( this ), status ), status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* TitleGap. */
/* --------- */
   } else if ( !strcmp( attrib, "titlegap" ) ) {
      dval = astGetTitleGap( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* MajTickLen. */
/* ----------- */
   } else if ( !strcmp( attrib, "majticklen" ) ) {
      dval = GetUsedMajTickLen( this, 0, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* MajTickLen(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "majticklen(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = GetUsedMajTickLen( this, axis - 1, status );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* MinTickLen. */
/* ----------- */
   } else if ( !strcmp( attrib, "minticklen" ) ) {
      dval = astGetMinTickLen( this, 0 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* MinTickLen(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "minticklen(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      dval = astGetMinTickLen( this, axis - 1 );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
         result = getattrib_buff;
      }

/* Labelling. */
/* ---------- */
   } else if ( !strcmp( attrib, "labelling" ) ) {
      ival = GetUsedLabelling( this, status );
      if ( astOK ) {
         result = ival ? xlbling[1] : xlbling[0];
      }

/* TextGapType. */
/* ------------ */
   } else if ( !strcmp( attrib, "textgaptype" ) ) {
      ival = astGetTextGapType( this );
      if ( astOK ) {
         result = ival ? xtgaptype[1] : xtgaptype[0];
      }

/* Edge(axis). */
/* ----------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "edge(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      ival = GetUsedEdge( this, axis - 1, status );
      if ( astOK ) {
         if( ival == LEFT ){
            result = "left";
         } else if( ival == RIGHT ){
            result = "right";
         } else if( ival == TOP ){
            result = "top";
         } else if( ival == BOTTOM ){
            result = "bottom";
         } else {
            result = "<bad>";
         }
      }

/* If the attribute name was not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_getattrib)( this_object, attrib, status );
   }

/* Unfreeze the bound box so that it may be updated by subsequent
   plotting functions. */
   Boxp_freeze = 0;

/* Return the result. */
   return result;
}

static AstPointSet *GetDrawnTicks( AstPlot *this, int axis, int major, int *status ){
/*
*+
*  Name:
*     astGetDrawnTicks

*  Purpose:
*     Return information about the ticks last drawn by astGrid.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot.h"
*     AstPointSet *GetDrawnTicks( AstPlot *this, int axis, int major )

*  Class Membership:
*     Plot method.

*  Description:
*     This function returns a PointSet holding information about the
*     tick marks (either major and minor) that were drawn by the previous
*     invocation of astGrid. A NULL pointer is returned if astGrid has
*     not yet been invoked.

*  Parameters:
*     this
*        Pointer to a Plot.
*     axis
*        The zero-based axis of the axis for which tick mark information
*        is required.
*     major
*        Supply a non-zero value if information about the major tick
*        marks is to be returned, and zero if information about the minor
*        tick marks is to be returned.

*  Returned Value:
*     A pointSet with one point for every tick of the requested type drawn
*     by astGrid for the specified axis. Each point has 2 coordinate values,
*     being the graphics coordinates at the start of the tick mark. The
*     returned PointSet pointer should be annulled when no longer needed.

*-
*/

/* Local Variables: */
   AstPointSet *result = NULL;
   double *ptr[ 3 ];
   int n;

/* Check the global status. */
   if( !astOK ) return result;

/* Report an error if the supplied axis value is incorrect. */
   if( axis < 0 || axis > 1 ) {
      astError( AST__INTER, "astGetDrawnTicks(Plot): Supplied \"axis\" "
                "value is %d - should 0 or 1 (internal AST programming "
                "error).", status, axis );
      n = 0;

/* If OK, get the number of stored tick marks. */
   } else {
      n = major ? this->majtickcount[ axis ] : this->mintickcount[ axis ];
   }

/* Check that information is available. */
   if( n > 0 && astOK ) {

/* Create a PointSet with the required size. */
      result = astPointSet( n, 2, "", status );

/* Store pointers to the arrays within the Plot that hold the required
   tick marks positions and types. */
      ptr[ 0 ] = major ? this->majtickgx[ axis ] : this->mintickgx[ axis ];
      ptr[ 1 ] = major ? this->majtickgy[ axis ] : this->mintickgy[ axis ];
      astSetPoints( result, ptr );
   }

/* Return the PointSet. */
   return result;
}

static double GetTicks( AstPlot *this, int axis, double *cen, double **ticks,
                        int *nmajor, double **minticks, int *nminor,
                        int format_set, int *inval, double *refval,
                        GetTicksStatics **pstatics, const char *method,
                        const char *class, int *status ){
/*
*  Name:
*     GetTicks

*  Purpose:
*     Obtain a list of logarithmically or linearly spaced tick mark values for
*     a single axis in a 2-D physical coordinate Frame.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     double GetTicks( AstPlot *this, int axis, double *cen, double **ticks,
*                      int *nmajor, double **minticks, int *nminor,
*                      int format_set, int *inval, double *refval,
*                      GetTicksStatics **pstatics, const char *method,
*                      const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     For linearly spaced major ticks the "gap" returned by this function
*     is the constant difference between adjacent major tick marks. For
*     logarithmically spaced major ticks the "gap" returned by this
*     function is the constant ratio between adjacent major tick marks.
*
*     If a gap size has been specified using attribute Gap (or LogGap for
*     logarithmic ticks) supplied, the specified value is returned, and used
*     to determine the tick values. If no gap size is supplied, a default
*     gap size is used and returned.
*
*     All this is over-ridden if the astSetTickValues method has been
*     called to store explicit tick mark values in the Plot structure.
*     In this case, the values supplied using astSetTickValues are
*     returned.

*  Parameters:
*     this
*        The Plot. Supplying a NULL pointer will cause statics resources
*        to be released.
*     axis
*        The zero-based index of the axis to use.
*     cen
*        Pointer to the supplied axis value at which to put a single
*        central tick. Other ticks will be placed evenly on either side
*        of this tick. If AST__BAD is provided, a value will be used
*        which would put a tick at an axis value of one. The used value
*        is returned.
*     ticks
*        Pointer to a place at which to return a pointer to the memory in
*        which are stored the major tick values to be used. This pointer
*        should be freed using astFree when no longer needed. The number of
*        values in the array is given by the value returned by parameter
*        "nmajor".
*     nmajor
*        A pointer to a location at which to return the number of major
*        ticks.
*     minticks
*        Pointer to a place at which to return a pointer to the memory in
*        which are stored the minor tick values to be used. This pointer
*        should be freed using astFree when no longer needed. The number of
*        values in the array is given by the value returned by parameter
*        "nminor". The minor tick marks values returned in this array are
*        the ones stored in the Plot via a call to the astSetTickValues
*        function. If this function has not been called, then a NULL
*        pointer is returned, and the "nminor" value is returned holding the
*        number of divisions between major ticks.
*     nminor
*        A pointer to a location at which to return either the number of
*        division into which each gap should be divided when drawing minor
*        tick marks (if "*minticks" is returned holding NULL), or the
*        total number of minor tick values stored in "*minticks" (if
*        "*minticks" is returned non-NULL). The number of divisions
*        between major tick values is one more than the number of minor
*        tick marks.
*     format_set
*        Indicates if an explicit format has been set for the axis. If
*        not, "cen" is always assumed to be AST__BAD, and any specified
*        Gap value is rounded to the nearest "nice" value. This has
*        to be done because the algorithm for choosing a format avoiding
*        unnecessary precision only works if the gap size causes 1 digit to
*        change between adjacent labels.
*     inval
*        A pointer to a location at which to return a flag indicating if
*        any invalid physical coordinates were encountered.
*     refval
*        A pointer to a location at which to return a value for the other
*        axis which can be used when normalizing the returned tick mark
*        values.
*     pstatics
*        Address of a pointer to a structure holding static data values
*        used within this function. A NULL pointer should be supplied on
*        the first invocation (dynamic memory will then be allocated to
*        hold ths structure). The memory is freed when a NULL value for
*        "this" is supplied.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The used gap size.

*  Notes:
*     -  This function allocates some static resources on its first
*     invocation, which should be released when no longer needed, or when
*     a different Plot is supplied, by calling this function with a NULL
*     pointer for parameter "this". All other parameters are ignored.
*     -  This function assumes that the physical coordinate system is 2
*     dimensional, and it should not be used if this is not the case.
*     -  An error is reported if the region containing valid physical
*     coordinates is too small to use.
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned in "ticks", zero
*     is returned for the number of major and minor ticks marks.
*/

/* Local Variables: */
   GetTicksStatics *statics; /* Pointer to statics structure */
   double *tick;             /* Pointer to next tick value */
   double cen0;              /* Supplied value of cen */
   double dran;              /* Dynamic range of axis values */
   double frac;              /* Fraction of plot area holding good coords */
   double gap;               /* Supplied value for Gap or LogGap */
   double log_used_gap;      /* Log10( the used gap size ) */
   double maxv;              /* Max axis value */
   double minv;              /* Min axis value */
   double new_used_gap;      /* New value for the used gap size */
   double old_used_gap;      /* Old value for the used gap size */
   double test_gap;          /* Trial gap size */
   double used_cen;          /* Used value of cen */
   double used_gap;          /* The used gap size */
   int findcen;              /* Find a new centre value? */
   int gap_too_small;        /* Test gap too small? */
   int gap_too_large;        /* Test gap too large? */
   int i;                    /* Axis index */
   int ihi;                  /* Highest tick mark index */
   int ilo;                  /* Lowest tick mark index */
   int nochange;             /* No. of ineffective attempts to change gap size */

/* Initialise the returned information. */
   *ticks = NULL;
   *minticks = NULL;
   *nmajor = 0;
   *nminor = 0;

/* Get a pointer to the supplied statics object. */
   statics = *pstatics;

/* If a NULL pointer has been supplied for "this", release the resources
   allocated on the first call to this function, and return. */
   if( !this ){
      if( statics ) {
         if( statics->map ) statics->map = astAnnul( statics->map );
         if( statics->pset ) statics->pset = astAnnul( statics->pset );
         if( statics->frame ) statics->frame = astAnnul( statics->frame );
         *pstatics = astFree( statics );
      }
      return 0.0;
   }

/* Check the global error status. */
   if ( !astOK ) return 0.0;

/* If no statics structure was supplied, create one now and initialise it. */
   if( !statics ) {
      statics = astMalloc( sizeof( GetTicksStatics ) );
      if( statics ) {
         statics->pset=NULL;
         *pstatics = statics;
      }
   }

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   maxv = 0.0;
   minv = 0.0;
   used_cen = 0.0;
   used_gap = 0.0;
   ihi = 0;
   ilo = 0;

/* If this is the first call to this function, do some initialisation. */
   if( !statics->pset ){

/* Get the Mapping from Base to Current Frame in the Plot. */
      statics->map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Get a pointer to the current Frame from the Plot. */
      statics->frame = astGetFrame( this, AST__CURRENT );

/* Get initial guesses at suitable gaps for each axis. A PointSet is
   returned holding sorted values (non-normalized) for the physical axes. */
      statics->pset = DefGap( this, statics->defgaps, statics->ngood, &frac, &statics->bad, method, class, status );

/* Store the maximum and minimum number of major tick marks along each
   axis. These numbers are reduced if only a small part of the plotting
   area contains valid coordinates, so that the tick marks do not end up
   to close together. */
      statics->maxticks = (int) ( 0.5 + MAJTICKS_MAX*sqrt( frac ) );
      statics->mintick = (int) ( 0.5 + MAJTICKS_MIN*sqrt( frac ) );
      if( statics->mintick < 3 ) statics->mintick = 3;
      if( statics->maxticks < 8 ) statics->maxticks = 8;
      if( statics->maxticks < statics->mintick ) statics->maxticks = statics->mintick;

/* Get a pointer to the data in the PointSet. */
      statics->ptr = astGetPoints( statics->pset );

/* Find a typical value on each axis. */
      for( i = 0; i < 2 && astOK; i++ ){
         statics->typval[ i ] = Typical( statics->ngood[ i ], statics->ptr[ i ], -DBL_MAX, DBL_MAX,
                                statics->width + i, status );
      }
   }

/* Return the flag indicating if any regions of invalid physical coordinates
   were found. */
   *inval = statics->bad;

/* Return the typical value on the other axis. */
   *refval = statics->typval[ 1 - axis ];

/* See if any tick marks values have been stored in the Plot structure
   using astSetTickValues. If so, copy the tick mark values to the
   returned arrays and exit with a gap size determined by the first two
   ticks. */
   if( this->nmajtickval[ axis ] > 0 ) {
      *ticks = astStore( NULL, this->majtickval[ axis ],
                         this->nmajtickval[ axis ]*sizeof(double) );
      *minticks = astStore( NULL, this->mintickval[ axis ],
                         this->nmintickval[ axis ]*sizeof(double) );
      *nmajor = this->nmajtickval[ axis ];
      *nminor = this->nmintickval[ axis ];

      if( *nmajor > 1 && (*ticks)[ 0 ] != AST__BAD &&
                         (*ticks)[ 1 ] != AST__BAD ) {
         used_gap = fabs( (*ticks)[ 1 ] - (*ticks)[ 0 ] );
      } else {
         used_gap = AST__BAD;
      }

      return used_gap;

   }

/* See if the user has specified a gap size. The default for astGetLogTicks is
   determined in DefGaps, so we can now decide whether to use attribute Gap
   or LogGap to get the user-supplied gap size. Obtain the requested gap
   attribute values for both physical axes. */
   if( astGetLogTicks( this, axis ) ) {
      gap = astGetLogGap( this, axis );
   } else {
      gap = astGetGap( this, axis );
   }

/* Find the maximum and minimum value in the plotting area. DefGap will
   have reported an error if minv*maxv is negative or zero. */
   if( astOK ) {
      maxv = statics->ptr[ axis ][ statics->ngood[ axis ] - 1 ];
      minv = statics->ptr[ axis ][ 0 ];
   }

/* First deal with logarithmically spaced ticks. */
   dran = ( minv != 0.0 ) ? maxv/minv : 0.0;
   if( astGetLogTicks( this, axis ) ) {

/* If the ratio of max and min data value is not larger than 10, report an
   error. */
      dran = ( minv != 0.0 ) ? maxv/minv :0.0;
      if( dran < 10.0 && dran > 0.1 ) {
         astError( AST__VSMAL, "%s(%s): Cannot produce logarithmically "
                   "spaced major tick marks on axis %d since the dynamic "
                   "range of the axis is too small.", status, method, class, axis + 1 );
      }

/* Should we find a new value for "cen"? */
      findcen = !cen || *cen == AST__BAD || !format_set;

/* Try to find a "nice" gap size, so long as the caller has not supplied
   a gap size. The default gap size obtained above is our initial guess. */
      if( gap == AST__BAD && astOK ){

/* Start off using the default gap found during the initialisation. */
         test_gap = statics->defgaps[ axis ];

/* Loop round until a gap size is found which gives an acceptable number
   of tick marks. Upto 10 gap sizes are tried. */
         for( i = 0; i < 10 && astOK; i++ ){

/* Find a "nice" gap size close to the current test gap size. Also find
   the number of minor tick marks to use with the nice gap size. Gaps for
   logarithmic axes are always powers of ten. */
            log_used_gap = (int) ( log10( test_gap ) + 0.5 );
            if( log_used_gap == 0.0 ) {
               log_used_gap = ( test_gap > 1.0 ) ? 1.0 : -1.0;
            }
            *nminor = 9;
            used_gap = pow( 10.0, log_used_gap );

/* If no value has been supplied for *cen, choose a value which would put
   a major tick mark at the value 1 (or -1), and which is mid way between
   the maximum and minimum axis value. */
            if( findcen ) {
               used_cen = pow( used_gap, (int) ( 0.5*log10( maxv*minv ) /
                                                 log_used_gap ) );
               if( maxv < 0 ) used_cen = -used_cen;
            } else {
               used_cen = *cen;
            }

/* Find the index of the highest tick which is not larger than the lowest
   axis value. */
            if( log_used_gap > 0.0 ) {
               ilo = floor(  log10( minv/used_cen )/log_used_gap );
            } else {
               ilo = ceil(  log10( minv/used_cen )/log_used_gap );
            }

/* Find the index of the lowest tick which is not less than the highest
   axis value. */
            if( log_used_gap > 0.0 ) {
               ihi = ceil(  log10( maxv/used_cen )/log_used_gap );
            } else {
               ihi = floor(  log10( maxv/used_cen )/log_used_gap );
            }

/* Find the total number of tick marks. */
            *nmajor = ihi - ilo + 1;

/* If the number of ticks is unacceptable, try a different gap size. If the
   gap was too large to produce any ticks, try using half the gap size. */
            if( *nmajor <= 0 ) {
               test_gap = sqrt( test_gap );

/* If there were some ticks, but not enough, decrease the gap size in
   proportion to the shortfall. */
            } else if( *nmajor < statics->mintick ){
               test_gap = pow( test_gap, (double)( *nmajor )/(double)( statics->mintick ) );

/* If there were too many ticks, increase the gap size in proportion to the
   excess. */
            } else if( *nmajor > statics->maxticks ){
               test_gap = pow( test_gap, (double)( *nmajor )/(double)( statics->maxticks ) );

/* If the number of ticks is acceptable, break out of the loop early.*/
            } else {
               break;
            }
         }

/* Increase the tick coverage by one at each end to cover up the gaps. */
         ilo--;
         ihi++;
         *nmajor += 2;

/* If an explicit gap size was supplied, use it. */
      } else if( astOK ) {

/* Check it is usable. */
         if( gap == 0.0 && astOK ) {
            astError( AST__ATTIN, "%s(%s): Invalid value zero given for "
                      "attribute LogGap(%d).", status, method, class, axis + 1 );

         } else if( gap < 0.0 && astOK ) {
            astError( AST__ATTIN, "%s(%s): Invalid negative value %f given for "
                      "attribute LogGap(%d).", status, method, class, gap, axis + 1 );

/* If necessary, take its reciprocal in order to ensure that the absolute
   tick mark values get smaller or larger as required. */
         } else {

            used_gap = gap;
            if( fabs( maxv ) < fabs( minv ) ) {
               if( gap > 1.0 ) used_gap = 1.0/gap;
            } else {
               if( gap < 1.0 ) used_gap = 1.0/gap;
            }

/* Find the nearest power of 10 ( do not allow 10**0 (=1.0) to be used). */
            log_used_gap = (int) ( log10( used_gap ) + 0.5 );
            if( log_used_gap == 0.0 ) {
              log_used_gap = ( gap > 1.0 ) ? 1.0 : -1.0;
            }
            used_gap = pow( 10.0, log_used_gap );

/* We always use 9 minor intervals. */
            *nminor = 9;

/* If no value has been supplied for *cen, choose a value which would put
   a major tick mark at the value 1 (or -1), and which is mid way between
   the maximum and minimum axis value. */
            if( findcen ) {
               used_cen = pow( used_gap, (int) ( 0.5*log10( maxv*minv ) /
                                                 log_used_gap ) );
               if( maxv < 0 ) used_cen = -used_cen;
            } else {
               used_cen = *cen;
            }

/* Find the index of the highest tick which is not larger than the lowest
   axis value. */
            if( log_used_gap > 0.0 ) {
               ilo = floor(  log10( minv/used_cen )/log_used_gap );
            } else {
               ilo = ceil(  log10( minv/used_cen )/log_used_gap );
            }

/* Find the index of the lowest tick which is not less than the highest
   axis value. */
            if( log_used_gap > 0.0 ) {
               ihi = ceil(  log10( maxv/used_cen )/log_used_gap );
            } else {
               ihi = floor(  log10( maxv/used_cen )/log_used_gap );
            }

/* Find the total number of tick marks. */
            *nmajor = ihi - ilo + 1;
            if( *nmajor < 2 && astOK ) {
               astError( AST__ATTIN, "%s(%s): Unusable value %f given for "
                      "attribute LogGap(%d).", status, method, class, gap, axis + 1 );

            }
         }
      }

/* Allocate memory to hold the tick values themselves. */
      *ticks = (double *) astMalloc( sizeof( double )*( *nmajor ) );
      if( astOK ) {

/* Store them. */
         tick = *ticks;
         for( i = ilo; i <= ihi; i++, tick++ ) {
            *tick = used_cen*pow( used_gap, i );
         }
      }

/* Store returned centre value. */
      if( cen ) *cen = used_cen;

/* Now deal with linearly spaced ticks */
   } else {

/* Store the supplied value of cen. */
      cen0 = ( cen ) ? *cen : AST__BAD;

/* If no format has been set for the axis, ensure AST__BAD is used for cen. */
      if( !format_set ) cen0 = AST__BAD;

/* Try to find a "nice" gap size, so long as the caller has not supplied
   a gap size. The default gap size obtained above is our initial guess. */
      if( gap == AST__BAD ){
         old_used_gap = AST__BAD;

/* Start of using the default gap found during the initialisation. */
         test_gap = statics->defgaps[ axis ];
         used_gap = 0.0;

/* Initialise flags saying the test gap is too large or too small */
         gap_too_large = 0;
         gap_too_small = 0;

/* So far, there have been no ineffective attempts to change the gap
   size. */
         nochange = 0;

/* Loop round until a gap size is found which gives an acceptable number
   of tick marks. Upto 10 gap sizes are tried. */
         for( i = 0; i < 10 && astOK; i++ ){

/* Find a "nice" gap size close to the current test gap size. Also find
   the number of minor tick marks to use with the nice gap size. */
            new_used_gap = astGap( statics->frame, axis, test_gap, nminor );

/* Find the number and positions of major tick marks which would result
   from using this gap size. Annul the memory used to hold any previous tick
   data first. Only do this if the gap being used has actually changed,
   otherwise we just retain the values created from the previous run with
   this gap size. */
            if( new_used_gap != used_gap ) {
               nochange = 0;
               old_used_gap = used_gap;
               used_gap = new_used_gap;
               if( *ticks ) *ticks = astFree( *ticks );
               if( cen ) *cen = cen0;
               *nmajor = FindMajTicks( statics->map, statics->frame, axis, *refval, statics->width[ 1-axis ],
                                       used_gap, cen, statics->ngood[ axis ],
                                       statics->ptr[ axis ], ticks, status );

/* If the gap size has not changed do an extra pass through this loop,
   but only do this a maximum of 25 times in succession. */
            } else if( nochange < 25 ) {
               nochange++;
               i--;

            } else if( astOK ){
               astError( AST__VSMAL, "%s(%s): Cannot produce enough major "
                         "tick marks on axis %d using the current axis "
                         "format (\"%s\").", status, method, class, axis + 1,
                         astGetFormat( statics->frame, axis ) );
               break;
            }

/* If the number of ticks is unacceptable, try a different gap size. If the
   gap was too large to produce any ticks, try using half the gap size. */
            if( *nmajor == 0 ) {
               test_gap *= 0.5;
               gap_too_large = 1;
               gap_too_small = 0;

/* If there were some ticks, but not enough... */
            } else if( *nmajor < statics->mintick ){

/* If the previous test gap produced too many ticks, use the current gap
   size. */
               if( gap_too_small ) {
                  break;

/* Otherwise, decrease the gap size in proportion to the shortfall. */
               } else {
                  test_gap *= (double)( *nmajor )/(double)( statics->mintick );
                  gap_too_large = 1;
                  gap_too_small = 0;
               }

/* If there were too many ticks... */
            } else if( *nmajor > statics->maxticks ){

/* If the previous test gap produced too few ticks, use the previous gap
   size. */
               if( gap_too_large ) {
                  used_gap = old_used_gap;
                  if( *ticks ) *ticks = astFree( *ticks );
                  if( cen ) *cen = cen0;
                  *nmajor = FindMajTicks( statics->map, statics->frame, axis, *refval, statics->width[ 1-axis ],
                                          used_gap, cen, statics->ngood[ axis ],
                                          statics->ptr[ axis ], ticks, status );
                  break;

/* Otherwise, increase the gap size in proportion to the excess. */
               } else {
                  test_gap *= (double)( *nmajor )/(double)( statics->maxticks );
                  gap_too_small = 1;
                  gap_too_large = 0;
               }

/* If the number of ticks is acceptable, break out of the loop early.*/
            } else {
               break;
            }
         }

/* If an explicit gap size was supplied, use it. */
      } else {

/* Find a likely value for the number of minor tick marks to use, and find
   a nice gap close to the supplied gap (unless an explicit format has
   been set). */
         if( format_set ){
            used_gap = gap;
            (void) astGap( statics->frame, axis, used_gap, nminor );
         } else {
            used_gap = astGap( statics->frame, axis, gap, nminor );
         }

/* Find where the major ticks should be put. */
         if( cen ) *cen = cen0;
         *nmajor = FindMajTicks( statics->map, statics->frame, axis, *refval, statics->width[ 1-axis ],
                                 used_gap, cen, statics->ngood[ axis ], statics->ptr[ axis ],
                                 ticks, status );
      }
   }

/* Report an error if no ticks can be found. */
   if( *nmajor == 0 && astOK ) {
      astError( AST__GRFER, "%s(%s): Cannot find any usable tick mark values. ", status, method,
                class );
   }

/* If an error has occurred, annul the memory used to hold tick data, and
   return zero ticks. */
   if( !astOK ) {
      *ticks = (double *) astFree( (void *) *ticks );
      *nmajor = 0;
      *nminor = 0;
      used_gap = 0.0;
   }

/* Return. */
   return used_gap;
}

static double GoodGrid( AstPlot *this, int *dim, AstPointSet **pset1,
                        AstPointSet **pset2, const char *method,
                        const char *class, int *status ){
/*
*  Name:
*     GoodGrid

*  Purpose:
*     Create a grid covering the region containing good coordinates in a
*     2-D physical coordinate Frame.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     double GoodGrid( AstPlot *this, int *dim, AstPointSet **pset1,
*                      AstPointSet **pset2, const char *method,
*                      const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function creates two PointSets, one holding a square grid of
*     graphics coordinates, and the other holding the corresponding physical
*     coordinates (not normalized). The grid covers just the area containing
*     good physical coordinates. The points are stored row by row in the
*     returned PointSets.

*  Parameters:
*     this
*        The Plot.
*     dim
*        A pointer to an integer in which to store the number of samples
*        along each edge of the returned grid.
*     pset1
*        A pointer to a location at which to store a pointer to the
*        PointSet holding the graphics coordinates.
*     pset2
*        A pointer to a location at which to store a pointer to the
*        PointSet holding the physical coordinates.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The fraction of the plotting area containing good physical
*     coordinates.

*  Notes:
*     -  This function assumes that the physical coordinate system is 2
*     dimensional, and it should not be used if this is not the case.
*     -  The returned PointSets should be annulled when no longer needed,
*     using astAnnul.
*     -  An error is reported if the region containing valid physical
*     coordinates is too small to use.
*     -  A function value of zero, and NULL pointers are returned if an error
*     has already occurred, or if this function should fail for any reason.
*/

/* Local Variables: */
   AstFrame *frm;     /* Pointer to the Current Frame in the Plot */
   AstMapping *map;   /* Pointer to "graphics to physical" mapping */
   double **ptr1;     /* Pointer to physical axis value data */
   double **ptr2;     /* Pointer to graphics axis value data */
   double *pa;        /* Pointer to next value on 1st physical axis */
   double *pb;        /* Pointer to next value on 2nd physical axis */
   double *px;        /* Pointer to next value on 1st graphics axis */
   double *py;        /* Pointer to next value on 2nd graphics axis */
   double dx;         /* Cell size along graphics X (1st) axis */
   double dy;         /* Cell size along graphics Y (2nd) axis */
   double frac;       /* Fraction of good physical coordinates */
   double xmax;       /* High X bound of region containing good phy. coords */
   double xmin;       /* Low X bound of region containing good phy. coords */
   double ymax;       /* High Y bound of region containing good phy. coords */
   double ymin;       /* Low Y bound of region containing good phy. coords */
   int j;             /* Element offset */
   int ngood;         /* Number of grid points with good physical coords */
   int size;          /* Number of grid points */

/* Initialise the returned PointSet pointers. */
   *pset1 = NULL;
   *pset2 = NULL;

/* Check the global error status. */
   if ( !astOK ) return 0.0;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   ptr1 = NULL;
   frac = 0.0;
   xmax = 0.0;
   xmin = 0.0;
   ymax = 0.0;
   ymin = 0.0;

/* Get the Mapping from base (graphics) to current (physical) Frame in the
   supplied Plot. */
   map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Get a pointer to the Current Frame in the Plot. */
   frm = astGetFrame( this, AST__CURRENT );

/* Initialise the grid dimension. */
   *dim = 16;

/* We need a grid which has at least 4 good points. */
   ngood = 0;
   while( ngood < 4 && astOK ){

/* Double the grid dimension. */
      *dim *= 2;

/* Report an error if the grid is now too big. */
      if( *dim >= 512 ){
         astError( AST__VSMAL, "%s(%s): The area of the plot containing "
                   "usable coordinates on both axes is too small.", status, method,
                   class );
         break;
      }

/* Get two PointSets, one holding a regular grid of graphics coordinates,
   and the other holding the corresponding physical coordinates. The grid
   covers the entire plotting area with the current grid dimension. A
   pointer to the physical axis values is returned. */
      ptr2 = MakeGrid( this, frm, map, 1, *dim, this->xlo, this->xhi, this->ylo,
                       this->yhi, 2, pset1, pset2, 0, method, class, status );

/* Get the number of graphics axis values. */
      size = astGetNpoint( *pset1 );

/* Get a pointer to the graphics axis values. */
      ptr1 = astGetPoints( *pset1 );

/* Check the pointers can be used. */
      if( astOK ){

/* Find the bounds in graphics coordinates of the area enclosing the
   good physical positions in the grid, and count the good positions. */
         ngood = 0;

         pa = ptr2[ 0 ];
         pb = ptr2[ 1 ];
         px = ptr1[ 0 ];
         py = ptr1[ 1 ];

         xmin = DBL_MAX;
         xmax = -DBL_MAX;
         ymin = DBL_MAX;
         ymax = -DBL_MAX;

         for( j = 0; j < size; j++ ){
            if( *pa != AST__BAD && *pb != AST__BAD ){
               if( *px < xmin ) xmin = *px;
               if( *px > xmax ) xmax = *px;
               if( *py < ymin ) ymin = *py;
               if( *py > ymax ) ymax = *py;
               ngood++;
            }
            px++;
            py++;
            pa++;
            pb++;
         }
      }
   }

/* Store approximate fraction of the plotting area containing good
   physical coordinates. */
   if( astOK ) {
      frac =  ( (double) ngood )/(double)( astGetNpoint( *pset1 ) );

/* Get the size of each grid cell. */
      dx = ptr1[0][1] - ptr1[0][0];
      dy = ptr1[1][1] - ptr1[1][0];

/* Extend the area containing good points by one grid cell. */
      xmax += dx;
      xmin -= dx;
      ymax += dy;
      ymin -= dy;

/* If the area containing good points is significantly smaller than
   the supplied area, create a new grid covering just the area containing
   good positions. */
      if( ( xmax - xmin ) < 0.9*( this->xhi - this->xlo ) ||
                  ( ymax - ymin ) < 0.9*( this->yhi - this->ylo ) ){

/* Find a new grid dimension which results in a cell size similar to
   the one used to create the grid, but covering only the region containing
   good physical coordinates. */
         *dim *= astMAX( (xmax - xmin)/(this->xhi - this->xlo),
                         (ymax - ymin)/(this->yhi - this->ylo) );
         if( *dim < 32 ) *dim = 32;

/* Annul the PointSet holding the current grid. */
         *pset1 = astAnnul( *pset1 );
         *pset2 = astAnnul( *pset2 );

/* Create the new grid covering the region containing good physical
   coordinates. */
         (void) MakeGrid( this, frm, map, 1, *dim, xmin, xmax, ymin, ymax, 2,
                          pset1, pset2, 0, method, class, status );
      }
   }

/* Annul the Mapping from base to current Frame, and the pointer to the
   Current Frame. */
   map = astAnnul( map );
   frm = astAnnul( frm );

/* If an error has occurred, annul the two pointsets and indicate that
   there are no good points in the plotting area. */
   if( !astOK ){
      *pset1 = astAnnul( *pset1 );
      *pset2 = astAnnul( *pset2 );
      frac = 0.0;
   }

/* Return. */
   return frac;

}

static int GraphGrid( int dim, int disk, double xlo, double xhi, double ylo,
                      double yhi, double **ptr1, int *status ){
/*
*  Name:
*     GraphGrid

*  Purpose:
*     Fill an array with a square grid of graphics coordinates.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GraphGrid( int dim, int disk, double xlo, double xhi, double ylo,
*                    double yhi, double **ptr1, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function fills the supplied array with a square grid of graphics
*     coordinates covering the supplied area. The points are stored row by
*     row, i.e. if the cell size for the grid is (dx,dy), the first point
*     is (xmin,ymin), followed by (xmin+dx,ymin), (xmin+2*dx,ymin), up to
*     (xmin+(dim-1)*dx,ymin), followed by the next row (xmin,ymin+dy),
*     (xmin+dx,ymin+dy), etc.

*  Parameters:
*     dim
*        The number of samples along each edge of the grid.
*     disk
*        If non-zero, the corners of the grid are omitted, resulting in a
*        grid that is more disk like than rectangular.
*     xlo
*        The lower bound on the first axis of the region to be covered
*        by the grid.
*     xhi
*        The upper bound on the first axis of the region to be covered
*        by the grid.
*     ylo
*        The lower bound on the second axis of the region to be covered
*        by the grid.
*     yhi
*        The upper bound on the second axis of the region to be covered
*        by the grid.
*     ptr1
*        A pointer to an array of two pointers giving the start of the two
*        arrays to receive the values for each of the two axes of the graphics
*        coordinate data.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The number of points in the grid. If "disk" is zero, this will be
*     the square of "dim". If "disk" is non-zero, this will be less than
*     the square of "dim" to account for the lack of corner points.

*/

/* Local Variables: */
   double *px;
   double *py;
   double cen;
   double dx;
   double dy2;
   double dy;
   double dx2;
   double r2;
   double y;
   int i;
   int j;
   int ok;

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Find the cell size. */
   dx = ( xhi - xlo )/(double)( dim - 1 );
   dy = ( yhi - ylo )/(double)( dim - 1 );

/* Store the mid cell index. */
   cen = 0.5*( dim - 1 );

/* Store the squared radius of the disk. */
   r2 = 1.9*cen*cen;

/* Initialise pointers to the start of the two arrays to recieve the
   returned graphics values for each axis. */
   px = ptr1[ 0 ];
   py = ptr1[ 1 ];

/* Loop round row. */
   for( j = 0; j < dim; j++ ){
      dy2 = j - cen;
      dy2 *= dy2;

/* Get the Y coordinate of the current row. */
      y = ylo + j*dy;

/* Loop round each column in the current row. */
      for( i = 0; i < dim; i++ ){

/* If we are forming a disk rather than a square, check if this point is
   sufficiently close to the centre to be included in the disk. */
         if( disk ) {
            dx2 = i - cen;
            dx2 *= dx2;
            ok = ( dx2 + dy2 <= r2 );
         } else {
            ok = 1;
         }

/* Store the coordinates of the current grid point. */
         if( ok ) {
            *(px++) = xlo + i*dx;
            *(py++) = y;
         }
      }
   }

/* Return the used length of the PointSet. */
   return (int)( px - ptr1[ 0 ] );
}

static void GrfPop( AstPlot *this, int *status ) {
/*
*++
*  Name:
c     astGrfPop
f     AST_GRFPOP

*  Purpose:
*     Restore previously saved graphics functions used by a Plot.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     void astGrfPop( AstPlot *this )
f     CALL AST_GRFPOP( THIS STATUS )

*  Class Membership:
*     Plot member function.

*  Description:
c     This function restores a snapshot of the graphics functions
c     stored previously by calling astGrfPush. The restored graphics
c     functions become the current graphics functions used by the Plot.
*
c     The astGrfPush and astGrfPop functions are intended for situations
c     where it is necessary to make temporary changes to the graphics
c     functions used by the Plot. The current functions should first be
c     saved by calling astGrfPush. New functions should then be registered
c     using astGrfSet. The required graphics should then be produced.
c     Finally, astGrfPop should be called to restore the original graphics
c     functions.
f     The AST_GRFPUSH and AST_GRFPOP functions are intended for situations
f     where it is necessary to make temporary changes to the graphics
f     functions used by the Plot. The current functions should first be
f     saved by calling AST_GRFPUSH. New functions should then be registered
f     using AST_GRFSET. The required graphics should then be produced.
f     Finally, AST_GRFPOP should be called to restore the original graphics
f     functions.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
f     - This routine returns without action if there are no snapshots to
c     - This function returns without action if there are no snapshots to
*     restore. No error is reported in this case.

*--
*/

/* Local Variables: */
   AstGrfPtrs *newframe;         /* Pointer to the stack frame to restore */
   int i;                        /* Loop count */

/* Check the global error status. */
   if ( !astOK ) return;

/* Check the stack is not already empty. */
   if( this->grfnstack > 0 ) {
      this->grfnstack--;

      if( astOK ) {
         newframe = this->grfstack + this->grfnstack;

         for( i = 0; i < AST__NGRFFUN; i++ ) {
            this->grffun[i] = (newframe->grffun)[i];
         }
         this->GAttr = newframe->GAttr;
         this->GBBuf = newframe->GBBuf;
         this->GEBuf = newframe->GEBuf;
         this->GFlush = newframe->GFlush;
         this->GLine = newframe->GLine;
         this->GMark = newframe->GMark;
         this->GText = newframe->GText;
         this->GCap = newframe->GCap;
         this->GTxExt = newframe->GTxExt;
         this->GScales = newframe->GScales;
         this->GQch = newframe->GQch;
      }
   }
}

static void GrfPush( AstPlot *this, int *status ) {
/*
*++
*  Name:
c     astGrfPush
f     AST_GRFPUSH

*  Purpose:
*     Save the current graphics functions used by a Plot.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     void astGrfPush( AstPlot *this )
f     CALL AST_GRFPUSH( THIS STATUS )

*  Class Membership:
*     Plot member function.

*  Description:
c     This function takes a snapshot of the graphics functions which are
f     This routine takes a snapshot of the graphics functions which are
*     currently registered with the supplied Plot, and saves the snapshot
*     on a first-in-last-out stack within the Plot. The snapshot can be
*     restored later using function
c     astGrfPop.
f     AST_GRFPOP.
*
c     The astGrfPush and astGrfPop functions are intended for situations
c     where it is necessary to make temporary changes to the graphics
c     functions used by the Plot. The current functions should first be
c     saved by calling astGrfPush. New functions should then be registered
c     using astGrfSet. The required graphics should then be produced.
c     Finally, astGrfPop should be called to restore the original graphics
c     functions.
f     The AST_GRFPUSH and AST_GRFPOP functions are intended for situations
f     where it is necessary to make temporary changes to the graphics
f     functions used by the Plot. The current functions should first be
f     saved by calling AST_GRFPUSH. New functions should then be registered
f     using AST_GRFSET. The required graphics should then be produced.
f     Finally, AST_GRFPOP should be called to restore the original graphics
f     functions.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*--
*/

/* Local Variables: */
   AstGrfPtrs *newframe;         /* Pointer to the new stack frame */
   int i;                        /* Loop count */

/* Check the global error status. */
   if ( !astOK ) return;

/* Increment the number of frames on the stack. */
   this->grfnstack++;

/* Ensure the stack is large enough to hold this many frames. */
   this->grfstack = (AstGrfPtrs *) astGrow( (void *) this->grfstack,
                     this->grfnstack, sizeof( AstGrfPtrs ) );
   if( astOK ) {

/* Get a pointer to the new stack frame. */
      newframe = this->grfstack + this->grfnstack - 1;

/* Copy the graphics function pointers from the main Plot attributes
   to the new stack frame. */
      for( i = 0; i < AST__NGRFFUN; i++ ) {
         (newframe->grffun)[i] = this->grffun[i];
      }
      newframe->GAttr = this->GAttr;
      newframe->GBBuf = this->GBBuf;
      newframe->GEBuf = this->GEBuf;
      newframe->GFlush = this->GFlush;
      newframe->GLine = this->GLine;
      newframe->GMark = this->GMark;
      newframe->GText = this->GText;
      newframe->GCap = this->GCap;
      newframe->GTxExt = this->GTxExt;
      newframe->GQch = this->GQch;
      newframe->GScales = this->GScales;
   }
}

static void GrfSet( AstPlot *this, const char *name, AstGrfFun fun, int *status ){
/*
*++
*  Name:
c     astGrfSet
f     AST_GRFSET

*  Purpose:
c     Register a graphics function for use by a Plot.
f     Register a graphics routine for use by a Plot.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     void astGrfSet( AstPlot *this, const char *name, AstGrfFun fun )
f     CALL AST_GRFSET( THIS, NAME, FUN, STATUS )

*  Class Membership:
*     Plot member function.

*  Description:
c     This function can be used to select the underlying graphics
c     functions to be used when the supplied Plot produces graphical output.
c     If this function is not called prior to producing graphical
c     output, then the underlying graphics functions selected at
c     link-time (using the ast_link command) will be used. To use
c     alternative graphics functions, call this function before
c     the graphical output is created, specifying the graphics
c     functions to be used. This will register the function for future
c     use, but the function will not actually be used until the Grf
c     attribute is given a non-zero value.
f     This routine can be used to select the underlying graphics
f     routines to be used when the supplied Plot produces graphical output.
f     If this routine is not called prior to producing graphical
f     output, then the underlying graphics routines selected at
f     link-time (using the ast_link command) will be used. To use
f     alternative graphics routines, call this routine before
f     the graphical output is created, specifying the graphics
f     routines to be used. This will register the routine for future
f     use, but the routine will not actually be used until the Grf
f     attribute is given a non-zero value.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     name
f     NAME = CHARACTER * ( * ) (Given)
c        A name indicating the graphics function to be replaced.
c        Various graphics functions are used by the
c        Plot class, and any combination of them may be supplied by calling
c        this function once for each function to be replaced. If any of the
c        graphics functions are not replaced in this way, the
c        corresponding functions in the graphics interface selected at
c        link-time (using the ast_link command) are used. The allowed
c        names are:
f        A name indicating the graphics routine to be replaced.
f        Various graphics routines are used by the
f        Plot class, and any combination of them may be supplied by calling
f        this routine once for each routine to be replaced. If any of the
f        graphics routines are not replaced in this way, the
f        corresponding routines in the graphics interface selected at
f        link-time (using the ast_link command) are used. The allowed
f        function names are:
*
*        - Attr -  Enquire or set a graphics attribute value
*        - BBuf - Start a new graphics buffering context
*        - Cap -  Inquire a capability
*        - EBuf - End the current graphics buffering context
*        - Flush - Flush all pending graphics to the output device
*        - Line - Draw a polyline (i.e. a set of connected lines)
*        - Mark -  Draw a set of markers
*        - Qch -  Return the character height in world coordinates
*        - Scales -  Get the axis scales
*        - Text - Draw a character string
*        - TxExt -  Get the extent of a character string
*
*        The string is case insensitive. For details of the interface
*        required for each, see the sections below.
c     fun
f     FUN = INTEGER FUNCTION (Given)
c        A Pointer to the function to be used to provide the
c        functionality indicated by parameter name. The interface for
c        each function is described below, but the function pointer should
c        be cast to a type of AstGrfFun when calling astGrfSet.
f        The name of the routine to be used to provide the
f        functionality indicated by parameter NAME (the name
f        should also appear in a Fortran EXTERNAL statement in the
f        routine which invokes AST_GRFSET).
*
c        Once a function has been provided, a null pointer can be supplied
c        in a subsequent call to astGrfSet to reset the function to the
c        corresponding function in the graphics interface selected at
c        link-time.
f        Once a routine has been provided, the "null" routine AST_NULL can
f        be supplied in a subsequent call to astGrfSet to reset the routine
f        to the corresponding routine in the graphics interface selected at
f        link-time. AST_NULL is defined in the AST_PAR include file.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Function Interfaces:
*     All the functions listed below (except for "Cap") should return an
*     integer value of 0 if an error occurs, and 1 otherwise. All x and y
*     values refer
f     to "graphics cordinates" as defined by the GRAPHBOX parameter of
f     the AST_PLOT call which created the Plot.
c     to "graphics cordinates" as defined by the graphbox parameter of
c     the astPlot call which created the Plot.
*
c     The first parameter ("grfcon")
f     The first argument (GRFCON)
*     for each function is an AST KeyMap pointer that can be used by the
*     called function to establish the context in which it is being called.
*     The contents of the KeyMap are determined by the calling
*     application, which should obtain a pointer to the KeyMap using the
f     AST_GETGRFCONTEXT routine,
c     astGetGrfContext function,
*     and then store any necessary information in the KeyMap using the
*     methods of the KeyMap class. Note, the functions listed below
*     should never annul or delete the supplied KeyMap pointer.

*  Attr:
*     The "Attr" function returns the current value of a specified graphics
*     attribute, and optionally establishes a new value. The supplied
*     value is converted to an integer value if necessary before use.
*     It requires the following interface:
*
c     int Attr( AstObject *grfcon, int attr, double value, double *old_value, int prim )
f     INTEGER FUNCTION ATTR( GRFCON, ATT, VAL, OLDVAL, PRIM )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - attr - An integer value identifying the required attribute.
c       The following symbolic values are defined in grf.h:
f     - ATT = INTEGER (Given) - An integer identifying the required attribute.
f       The following symbolic values are defined in GRF_PAR:
*       GRF__STYLE (Line style),
*       GRF__WIDTH (Line width),
*       GRF__SIZE (Character and marker size scale factor),
*       GRF__FONT (Character font),
*       GRF__COLOUR (Colour index).
c     - value -
f     - VAL = DOUBLE PRECISION (Given) -
c       A new value to store for the attribute. If this is AST__BAD
*       no value is stored.
c     - old_value - A pointer to a double in which to return
f     - OLDVAL = DOUBLE PRECISION (Returned) - Returned holding
*       the attribute value.
c       If this is NULL, no value is returned.
c     - prim -
f     - PRIM = INTEGER (Given) -
*       The sort of graphics primitive to be drawn with the new attribute.
c       Identified by the following values defined in grf.h:
f       Identified by the following values defined in GRF_PAR:
*       GRF__LINE,
*       GRF__MARK,
*       GRF__TEXT.

*  BBuf:
*     The "BBuf" function should start a new graphics buffering context.
*     A matching call to the function "EBuf" should be used to end the
*     context. The nature of the buffering is determined by the underlying
*     graphics system.
*
c     int BBuf( AstObject *grfcon )
f     INTEGER FUNCTION BBUF( GRFCON )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.

*  Cap:
*     The "Cap" function is called to determine if the grf module has a
*     given capability, as indicated by the "cap" argument:
*
c     int Cap( AstObject *grfcon, int cap, int value )
f     INTEGER FUNCTION CAP( GRFCON, CAP, VALUE )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - cap -
f     - CAP = INTEGER (Given)
*        The capability being inquired about. This will be one of the
c        following constants defined in grf.h:
f        following constants defined in GRF_PAR:
*
*        GRF__SCALES: This function should return a non-zero value if the
*        "Scales" function is implemented, and zero otherwise. The supplied
c        "value" argument should be ignored.
f        VALUE argument should be ignored.
*
*        GRF__MJUST: This function should return a non-zero value if
*        the "Text" and "TxExt" functions recognise "M" as a
*        character in the justification string. If the first character of
*        a justification string is "M", then the text should be justified
*        with the given reference point at the bottom of the bounding box.
*        This is different to "B" justification, which requests that the
*        reference point be put on the baseline of the text, since some
*        characters hang down below the baseline. If the "Text" or
*        "TxExt" function cannot differentiate between "M" and "B",
*        then this function should return zero, in which case "M"
*        justification will never be requested by Plot. The supplied
c        "value" argument should be ignored.
f        VALUE argument should be ignored.
*
*        GRF__ESC: This function should return a non-zero value if the
*        "Text" and "TxExt" functions can recognise and interpret
*        graphics escape sequences within the supplied string (see
*        attribute Escape). Zero should be returned if escape sequences
*        cannot be interpreted (in which case the Plot class will interpret
c        them itself if needed). The supplied "value" argument should be
f        them itself if needed). The supplied VALUE argument should be
*        ignored only if escape sequences cannot be interpreted by "Text" and
c        "TxExt". Otherwise, "value" indicates whether "Text" and "TxExt"
c        should interpret escape sequences in subsequent calls. If "value" is
f        "TxExt". Otherwise, VALUE indicates whether "Text" and "TxExt"
f        should interpret escape sequences in subsequent calls. If VALUE is
*        non-zero then escape sequences should be interpreted by "Text" and
*        "TxExt". Otherwise, they should be drawn as literal text.
*
c     - value -
f     - VALUE = INTEGER (Given)
c        The use of this parameter depends on the value of "cap" as
f        The use of this parameter depends on the value of CAP as
*        described above.

*     - Returned Function Value:
c        The value returned by the function depends on the value of "cap"
f        The value returned by the function depends on the value of CAP
*        as described above. Zero should be returned if the supplied
*        capability is not recognised.

*  EBuf:
*     The "EBuf" function should end the current graphics buffering
*     context. See the description of "BBuf" above for further details.
*     It requires the following interface:
*
c     int EBuf( AstObject *grfcon )
f     INTEGER FUNCTION EBUF( GRFCON )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.

*  Flush:
*     The "Flush" function ensures that the display device is up-to-date,
*     by flushing any pending graphics to the output device. It
*     requires the following interface:
*
c     int Flush( AstObject *grfcon )
f     INTEGER FUNCTION FLUSH( GRFCON )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.

*  Line:
*     The "Line" function displays lines joining the given positions and
*     requires the following interface:
*
c     int Line( AstObject *grfcon, int n, const float *x, const float *y )
f     INTEGER FUNCTION LINE( GRFCON, N, X, Y )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - n - The number of positions to be joined together.
f     - N = INTEGER (Given) - The number of positions to be joined together.
c     - x - A pointer to an array holding the "n" x values.
f     - X( N ) = REAL (Given) - An array holding the "n" x values.
c     - y - A pointer to an array holding the "n" y values.
f     - Y( N ) = REAL (Given) - An array holding the "n" y values.

*  Mark:
*     The "Mark" function displays markers at the given positions. It
*     requires the following interface:
*
c     int Mark( AstObject *grfcon, int n, const float *x, const float *y, int type )
f     INTEGER FUNCTION MARK( GRFCON, N, X, Y, TYPE )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - n - The number of positions to be marked.
f     - N = INTEGER (Given) - The number of positions to be marked.
c     - x - A pointer to an array holding the "n" x values.
f     - X( N ) = REAL (Given) - An array holding the "n" x values.
c     - y - A pointer to an array holding the "n" y values.
f     - Y( N ) = REAL (Given) - An array holding the "n" y values.
c     - type - An integer which can be used to indicate the type of marker
c       symbol required.
f     - TYPE = INTEGER (Given) - An integer which can be used to indicate
f       the type of marker symbol required.

*  Qch:
*     The "Qch" function returns the heights of characters drawn vertically
*     and horizontally in graphics coordinates. It requires the following
*     interface:
*
c     int Qch( AstObject *grfcon, float *chv, float *chh )
f     INTEGER FUNCTION QCH( GRFCON, CHV, CHH )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - chv - A pointer to the float which is to receive the height of
f     - CHV = REAL (Returned) The height of
*     characters drawn with a vertical baseline. This will be an
*     increment in the X axis.
c     - chh - A pointer to the float which is to receive the height of
f     - CHH = REAL (Returned) The height of
*     characters drawn with a horizontal baseline. This will be an
*     increment in the Y axis.

*  Scales:
*     The "Scales" function returns two values (one for each axis) which
*     scale increments on the corresponding axis into a "normal" coordinate
*     system in which: 1) the axes have equal scale in terms of (for instance)
*     millimetres per unit distance, 2) X values increase from left to
*     right, and 3) Y values increase from bottom to top. It requires the
*     following interface:
*
c     int Scales( AstObject *grfcon, float *alpha, float *beta )
f     INTEGER FUNCTION SCALES( GRFCON, ALPHA, BETA )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - alpha - A pointer to the float which is to receive the
f     - ALPHA = REAL (Returned) The
*     scale for the X axis (i.e. Xnorm = alpha*Xworld).
c     - beta - A pointer to the float which is to receive the
f     - BETA = REAL (Returned) The
*     scale for the Y axis (i.e. Ynorm = beta*Yworld).

*  Text:
*     The "Text" function displays a character string at a given
*     position using a specified justification and up-vector. It
*     requires the following interface:
*
c     int Text( AstObject *grfcon, const char *text, float x, float y, const char *just,
c               float upx, float upy )
f     INTEGER FUNCTION TEXT( GRFCON, TEXT, X, Y, JUST, UPX, UPY )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - text - Pointer to a null-terminated character string to be displayed.
f     - TEXT = CHARACTER * ( * ) (Given) - The string to be displayed.
c     - x - The reference x coordinate.
f     - X = REAL (Given) - The reference x coordinate.
c     - y - The reference y coordinate.
f     - Y = REAL (Given) - The reference y coordinate.
c     - just - A character string which specifies the location within the
f     - JUST = CHARACTER * ( * ) (Given ) - A string which specifies the
f        location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
c     - upx - The x component of the up-vector for the text.
f     - UPX = REAL (Given) - The x component of the up-vector for the text.
*        If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
c     - upy - The y component of the up-vector for the text.
f     - UPX = REAL (Given) - The y component of the up-vector for the text.
*        If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.

*  TxExt:
*     The "TxExt" function returns the corners of a box which would enclose
*     the supplied character string if it were displayed using the
*     Text function described above. The returned box includes any leading
*     or trailing spaces. It requires the following interface:
*
c     int TxExt( AstObject *grfcon, const char *text, float x, float y, const char *just,
c                float upx, float upy, float *xb, float *yb )
f     INTEGER FUNCTION TXEXT( GRFCON, TEXT, X, Y, JUST, UPX, UPY, XB, YB )
*
c     - grfcon -
f     - GRFCON = INTEGER (Given) -
*       A KeyMap containing information passed from the calling application.
c     - text - Pointer to a null-terminated character string to be displayed.
f     - TEXT = CHARACTER * ( * ) (Given) - The string to be displayed.
c     - x - The reference x coordinate.
f     - X = REAL (Given) - The reference x coordinate.
c     - y - The reference y coordinate.
f     - Y = REAL (Given) - The reference y coordinate.
c     - just - A character string which specifies the location within the
f     - JUST = CHARACTER * ( * ) (Given ) - A string which specifies the
f        location within the
*        text string which is to be placed at the reference position
*        given by x and y. See "Text" above.
c     - upx - The x component of the up-vector for the text.
f     - UPX = REAL (Given) - The x component of the up-vector for the text.
*        See "Text" above.
c     - upy - The y component of the up-vector for the text.
f     - UPX = REAL (Given) - The y component of the up-vector for the text.
*        See "Text" above.
c     - xb - An array of 4 elements in which to return the x coordinate of
f     - XB( 4 ) = REAL (Returned) - Returned holding the x coordinate of
*        each corner of the bounding box.
c     - yb - An array of 4 elements in which to return the y coordinate of
f     - YB( 4 ) = REAL (Returned) - Returned holding the y coordinate of
*        each corner of the bounding box.

*--
*/

/* Local Variables: */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   int ifun;               /* Index into grf function list */
   void (* wrapper)();     /* Wrapper function for C Grf routine*/

/* Check the global error status. */
   if ( !astOK ) return;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   wrapper = NULL;

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astGrfSet";
   class = astClass( this );

/* Identify the supplied function name and get its integer index into the
   list of grf functions. */
   ifun = astGrfFunID( name, method, class );

/* Store the pointer. */
   if( astOK ) {
      this->grffun[ifun] = fun;

/* In general, the interface to each Grf function will differ for
   different languages. So we need a wrapper function with a known fixed
   interface which can be used to invoke the actual Grf function with
   an interface suited to the language in use. Call astGrfWrapper to store
   a wrapper to a suitable function which can invoke the supplied
   grf function. Here, we assume that the supplied function has a C
   interface, so we set up a C wrapper. If this function is being called
   from another language, then the interface for this function within
   that language should set up an appropriate wrapper after calling this
   function, thus over-riding the C wrapper set up here. */
      if( ifun == AST__GATTR ) {
         wrapper = (AstGrfWrap) CGAttrWrapper;

      } else if( ifun == AST__GBBUF ) {
         wrapper = (AstGrfWrap) CGBBufWrapper;

      } else if( ifun == AST__GEBUF ) {
         wrapper = (AstGrfWrap) CGEBufWrapper;

      } else if( ifun == AST__GFLUSH ) {
         wrapper = (AstGrfWrap) CGFlushWrapper;

      } else if( ifun == AST__GLINE ) {
         wrapper = (AstGrfWrap) CGLineWrapper;

      } else if( ifun == AST__GMARK ) {
         wrapper = (AstGrfWrap) CGMarkWrapper;

      } else if( ifun == AST__GTEXT ) {
         wrapper = (AstGrfWrap) CGTextWrapper;

      } else if( ifun == AST__GCAP ) {
         wrapper = (AstGrfWrap) CGCapWrapper;

      } else if( ifun == AST__GTXEXT ) {
         wrapper = (AstGrfWrap) CGTxExtWrapper;

      } else if( ifun == AST__GSCALES ) {
         wrapper = (AstGrfWrap) CGScalesWrapper;

      } else if( ifun == AST__GQCH ) {
         wrapper = (AstGrfWrap) CGQchWrapper;

      } else if( astOK ) {
         astError( AST__INTER, "%s(%s): AST internal programming error - "
                   "Grf function id %d not yet supported.", status, method, class,
                   ifun );
      }
      astGrfWrapper( this, name, wrapper );
   }
}

int astGrfFunID_( const char *name, const char *method, const char *class, int *status ) {
/*
*+
*  Name:
*     astGrfFunID

*  Purpose:
*     Return the integer identifier for a given GRF routine.

*  Type:
*     Hidden public function.

*  Synopsis:
*     #include "plot.h"
*     int astGrfFunID( const char *name, const char *method,
*                      const char *class )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function returns an integer identifying the named grf function.
*     An error is reported if the named function is unknown. This function
*     is used by non-class modules within AST (e.g. fplot.c) which is why
*     it is public. It is not intended to be used by the public.

*  Parameters:
*     name
*        The grf function name. Any unambiguous abbreviation will do.
*        Case is ignored. The full list of grf function names is:
*        "Attr BBuf EBuf Scales Flush Line Mark Qch Text TxExt". See
*        grf_pgplot.c for details of these functions.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.

*-
*/

/* Note that the list of identifiers here must be in the same order as the
   sorted values of the constants AST__GATTR, AST__GFLUSH, etc */
   return FullForm( "Attr Flush Line Mark Text TxExt Scales Qch Cap BBuf "
                    "EBuf", name, "Grf function name (programming error)",
                    method, class, status );
}

static char *GrfItem( int item, const char *text, int *axis, int *status ){
/*
*  Name:
*     GrfItem

*  Purpose:
*     Return the textual name corresponding to a specified graphical item
*     index.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     char *GrfItem( int item, const char *text, int *axis, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function returns a textual description of the graphical item
*     with the supplied index.

*  Parameters:
*     item
*        The index of the graphical item.
*     text
*        A pointer to a string which will be appended to the textual
*        description of the graphical item. May be NULL.
*     axis
*        Pointer to a place in which to return the index (0,1, or 2) of
*        the axis to which the attribute refers, If the attribute does
*        not refer to a specific axis, -1 is returned.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a dynamically allocated string holding the textual
*     description of the graphical item, followed by any supplied "text".

*  Notes:
*     - An error is reported and a NULL pointer returned if the
*     index does not correspond to any graphical item.
*     - The returned pointer should be freed using astFree when it is no
*     longer needed.
*     - This function attempts to execute even if an error has already
*     occurred.

*/

/* Local Variables: */
   char *desc;              /* Pointer to the item description */
   char *ret;               /* Pointer to the returned string */
   int dlen;                /* Length of the item description */

   if( axis ) *axis = -1;

   if( item == AST__BORDER_ID ) {
      desc = "Border";

   } else if ( item == AST__GRIDLINE_ID ) {
      desc = "Gridline";

   } else if ( item == AST__GRIDLINE1_ID ) {
      desc = "Axis 1 gridline";
      if( axis ) *axis = 0;

   } else if ( item == AST__GRIDLINE2_ID ) {
      desc = "Axis 2 gridline";
      if( axis ) *axis = 1;

   } else if ( item == AST__GRIDLINE3_ID ) {
      desc = "Axis 3 gridline";
      if( axis ) *axis = 2;

   } else if ( item == AST__CURVE_ID ) {
      desc = "Curve";

   } else if ( item == AST__NUMLABS_ID ) {
      desc = "Numerical labels";

   } else if ( item == AST__TEXTLABS_ID ) {
      desc = "Textual labels";

   } else if ( item == AST__TITLE_ID ) {
      desc = "Title";

   } else if ( item == AST__MARKS_ID ) {
      desc = "Markers";

   } else if ( item == AST__TEXT_ID ) {
      desc = "Text string";

   } else if ( item == AST__TICKS_ID ) {
      desc = "Major and minor ticks";

   } else if ( item == AST__AXIS1_ID ) {
      desc = "Axis 1";
      if( axis ) *axis = 0;

   } else if ( item == AST__AXIS2_ID ) {
      desc = "Axis 2";
      if( axis ) *axis = 1;

   } else if ( item == AST__AXIS3_ID ) {
      desc = "Axis 3";
      if( axis ) *axis = 2;

   } else if ( item == AST__NUMLAB1_ID ) {
      desc = "Axis 1 numerical labels";
      if( axis ) *axis = 0;

   } else if ( item == AST__NUMLAB2_ID ) {
      desc = "Axis 2 numerical labels";
      if( axis ) *axis = 1;

   } else if ( item == AST__NUMLAB3_ID ) {
      desc = "Axis 3 numerical labels";
      if( axis ) *axis = 2;

   } else if ( item == AST__TEXTLAB1_ID ) {
      desc = "Axis 1 textual label";
      if( axis ) *axis = 0;

   } else if ( item == AST__TEXTLAB2_ID ) {
      desc = "Axis 2 textual label";
      if( axis ) *axis = 1;

   } else if ( item == AST__TEXTLAB3_ID ) {
      desc = "Axis 3 textual label";
      if( axis ) *axis = 2;

   } else if ( item == AST__TICKS1_ID ) {
      desc = "Axis 1 tick marks";
      if( axis ) *axis = 0;

   } else if ( item == AST__TICKS2_ID ) {
      desc = "Axis 2 tick marks";
      if( axis ) *axis = 1;

   } else if ( item == AST__TICKS3_ID ) {
      desc = "Axis 3 tick marks";
      if( axis ) *axis = 2;

   } else {
      desc = NULL;
      if( astOK ){
         astError( AST__INTER, "GrfItem: AST internal programming error - "
                   "Invalid graphical item index %d supplied to GrfItem.", status,
                   item );
      }
   }

   if( desc ) {
      dlen = strlen( desc );

      if( text ) {
         ret = astStore( NULL, desc, dlen + strlen( text ) + 1 );
         if( ret ) strcpy( ret + dlen, text );
      } else {
         ret = astStore( NULL, desc, dlen + 1 );
      }

   } else {
      ret = NULL;
   }

/* Return the answer. */
   return ret;
}

static void GrfWrapper( AstPlot *this, const char *name, AstGrfWrap wrapper, int *status ) {
/*
*+
*  Name:
*     astGrfWrapper

*  Purpose:
*     Register a wrapper function for a F77 or C Grf function.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     void astGrfWrapper( AstPlot *this, const char *name, AstGrfWrap wrapper)

*  Description:
*     This function stores a pointer to the supplied wrapper function
*     within the plot, associating it with the grf function indicated by
*     the "name" parameter. The supplied wrapper function should call the
*     named grf function, using an interface appropriate to the language
*     in which the grf function is written.

*  Parameters:
*     this
*        The plot.
*     name
*        A name indicating the graphics function which is called by the
*        supplied wrapper function. See astGrfSet for details.
*     wrapper
*        A pointer to the wrapper function. This will be cast to a
*        specific type for the named grf function before being store
*        in the Plot.
*-
*/

/* Local Variables: */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   int ifun;               /* Index into grf function list */

/* Check the global error status. */
   if ( !astOK ) return;

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astGrfWrapper";
   class = astClass( this );

/* Identify the supplied function name and get its integer index into the
   list of grf functions. */
   ifun = astGrfFunID( name, method, class );

/* Cast the wrapper to an interface appropriate for the wrapped grf
   function, and store it in the appropriate component of the Plot. */
   if( ifun == AST__GATTR ) {
      this->GAttr = (AstGAttrWrap) wrapper;

   } else if( ifun == AST__GBBUF ) {
      this->GBBuf = (AstGBBufWrap) wrapper;

   } else if( ifun == AST__GEBUF ) {
      this->GEBuf = (AstGEBufWrap) wrapper;

   } else if( ifun == AST__GFLUSH ) {
      this->GFlush = (AstGFlushWrap) wrapper;

   } else if( ifun == AST__GLINE ) {
      this->GLine = (AstGLineWrap) wrapper;

   } else if( ifun == AST__GMARK ) {
      this->GMark = (AstGMarkWrap) wrapper;

   } else if( ifun == AST__GTEXT ) {
      this->GText = (AstGTextWrap) wrapper;

   } else if( ifun == AST__GCAP ) {
      this->GCap = (AstGCapWrap) wrapper;

   } else if( ifun == AST__GTXEXT ) {
      this->GTxExt = (AstGTxExtWrap) wrapper;

   } else if( ifun == AST__GSCALES ) {
      this->GScales = (AstGScalesWrap) wrapper;

   } else if( ifun == AST__GQCH ) {
      this->GQch = (AstGQchWrap) wrapper;

   } else if( astOK ) {
      astError( AST__INTER, "%s(%s): AST internal programming error - "
                "Grf function id %d not yet supported.", status, method, class,
                ifun );
   }
}

static void Grid( AstPlot *this_nd, int *status ){
/*
*++
*  Name:
c     astGrid
f     AST_GRID

*  Purpose:
*     Draw a set of labelled coordinate axes.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astGrid( AstPlot *this )
f     CALL AST_GRID( THIS, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function draws a complete annotated set of
f     This routine draws a complete annotated set of
*     coordinate axes for a Plot with (optionally) a coordinate grid
*     superimposed. Details of the axes and grid can be controlled by
*     setting values for the various attributes defined by the Plot
*     class (q.v.).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - If the supplied Plot is a Plot3D, the axes will be annotated
*     using three 2-dimensional Plots, one for each 2D plane in the 3D
*     current coordinate system. The plots will be "pasted" onto 3 faces
*     of the cuboid graphics volume specified when the Plot3D was
*     constructed. The faces to be used can be controlled by the "RootCorner"
*     attribute.
*     - An error results if either the current Frame or the base Frame
*     of the Plot is not 2-dimensional or (for a Plot3D) 3-dimensional.
*     - An error also results if the transformation between the base
*     and current Frames of the Plot is not defined in either
*     direction (i.e. the Plot's TranForward or TranInverse attribute
*     is zero).
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   AstPlot *this;          /* Plot with 2d current Frame */
   AstPlotCurveData **cdata;/* Pointer to info. about breaks in curves */
   TickInfo **grid;        /* Pointer to info. about tick marks */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   double cen[ 2 ];        /* Position of first tick mark */
   double gap[ 2 ];        /* Gap between tick marks */
   double labelat[ 2 ];    /* Axis values at which tick marks are put */
   int axis;               /* Physical axis index */
   int border;             /* Draw a border? */
   int clip;               /* Original Clip attribute value */
   int dounits[2];         /* Include Units in each axis label? */
   int drawgrid;           /* Is a grid of lines to be drawn? */
   int clredge;            /* Clear the Edge attributes before returning? */
   int edgeticks;          /* Draw labels round edges of plotting area? */
   int escs;               /* Original astEscapes value */
   int ink;                /* Draw the grid with visible ink? */
   int inval;              /* Were areas of invalid coordinates found? */
   int labelling;          /* Value of Labelling attribute */
   int loglabelset[2];     /* Were the LogLabel attributes set initially? */
   int logticksset[2];     /* Were the LogTicks attributes set initially? */
   int naxes;              /* No. of axes in the base or current Frame */
   int oldedge0;           /* Default value for Edge(1) */
   int oldedge1;           /* Default value for Edge(2) */
   int useint;             /* Do interior labels give us an advantage? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this_nd);

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astGrid";
   class = astClass( this_nd );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this_nd );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Ensure AST functions included graphical escape sequences in any
   returned text strings. */
   escs = astEscapes( 1 );

/* Note if attributes which have complex dynamic defaults are set
   initially. */
   logticksset[0] = astTestLogTicks( this_nd, 0 );
   logticksset[1] = astTestLogTicks( this_nd, 1 );
   loglabelset[0] = astTestLogLabel( this_nd, 0 );
   loglabelset[1] = astTestLogLabel( this_nd, 1 );

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Get a Plot with a 2D (or 1D) current Frame. */
   this = (AstPlot *) Fset2D( (AstFrameSet *) this_nd, AST__CURRENT, status );

/* Check the current Frame of the Plot is 2-D. */
   naxes = astGetNout( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the current "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Ensure that all lines are clipped at the plot boundary.*/
   if( astTestClip( this ) ) {
      clip = astGetClip( this );
      astSetClip( this, 1 );
   } else {
      clip = -1;
   }

/* If the protected attribute "Ink" is set to zero, then the plot
   is drawn in "invisble ink" (i.e. all the calculations needed to
   produce the grid are performed, but nothing is actually drawn). */
   ink = astGetInk( this );

/* Initialise the bounds of the box containing all plotted lines and
   numerical labels. */
   Box_lbnd[ 0 ] = FLT_MAX;
   Box_lbnd[ 1 ] = FLT_MAX;
   Box_ubnd[ 0 ] = FLT_MIN;
   Box_ubnd[ 1 ] = FLT_MIN;

/* Obtain the requested centre attribute values for both physical axes. */
   for( axis = 0; axis < 2; axis++ ){
      cen[ axis ] = astGetCentre( this, axis );
   }

/* Determine where to put the major axis values. */
   grid = GridLines( this, cen, gap, &inval, method, class, status );

/* If the user has set an explicit value for Grid, use it. */
   if( astTestGrid( this ) ){
      drawgrid = astGetGrid( this );

/* If not, the default for Grid is based on whether or not there are any
   invalid regions. */
   } else if( inval ){
      drawgrid = 1;

   } else {
      drawgrid = 0;
   }

/* Draw the curves marking the major tick values on each axis. Information
   is returned describing the positions of the breaks in these curves. */
   cdata = DrawGrid( this, grid, ( ink && drawgrid ), method, class, status );

/* See if labels and tick marks will be drawn round the edges of the
   plotting area, rather than within it (no labels are actually drawn
   yet). Interior labels can always be produced, in which case edgeticks
   is set explicitly to zero to indicate that ticks will be internal.
   Exterior labelling may or may not be possible. If it is requested,
   check to see if it is possible. */
   clredge = 0;
   labelling = astGetLabelling( this );
   if( labelling ){
      edgeticks = 0;
   } else {
      edgeticks = EdgeLabels( this, 0, grid, cdata, 0, method, class, status );

/* If the external labelling was requested, but could not be produced... */
      if( !edgeticks ) {

/* and if the Edge attributes have not been set... */
         if( !astTestEdge( this, 0 ) && !astTestEdge( this, 1 ) ) {

/* Try flipping the default Edge values, to see if this allows us to
   honour the requested Labelling scheme. */
            oldedge0 = astGetEdge( this, 0 );
            oldedge1 = astGetEdge( this, 1 );
            astSetEdge( this, 0, oldedge1 );
            astSetEdge( this, 1, oldedge0 );

/* See if exterior labels could be drawn with these new edges. */
            edgeticks = EdgeLabels( this, 0, grid, cdata, 0, method, class, status );

/* If this would allow us to use the requested labelling scheme, retain
   the new Edge values, setting a flag to indicate that they will need to be
   cleared before returning. Otherwise, clear them. */
            if( edgeticks ) {
               clredge = 1;

            } else {
               astClearEdge( this, 0 );
               astClearEdge( this, 1 );
            }
         }
      }
   }

/* If edge ticks can still not be produced, but the ForceExterior attribute
   has a non-zero value, attempt to create exterior labels even though it
   looks like there may be insufficient of them to justify their use. */
   if( !edgeticks && astGetForceExterior( this ) ) {
      edgeticks = EdgeLabels( this, 0, grid, cdata, 1, method, class, status );
   }

/* We may also need to swap edge values when using interior labelling in
   order to ensure that the text labels are placed on appropriate edges of
   the plotting box. */
   if( !edgeticks && !astTestEdge( this, 0 ) && !astTestEdge( this, 1 ) ) {
      if( swapEdges( this, grid, cdata, status ) ) {
         oldedge0 = astGetEdge( this, 0 );
         oldedge1 = astGetEdge( this, 1 );
         astSetEdge( this, 0, oldedge1 );
         astSetEdge( this, 1, oldedge0 );
         clredge = 1;
      }
   }

/* If edge ticks are being used, store bad values for the labelat values to
   indicate that labels are not being drawn within the interior of the
   plotting area. */
   if( edgeticks ){
      labelat[ 0 ] = AST__BAD;
      labelat[ 1 ] = AST__BAD;

/* Otherwise, see where interior labels and tick marks should go (the axis
   values are put in "labelat"). */
   } else {
      useint = Labelat( this, grid, cdata, labelat, method, class, status );

/* If interior labelling does not allow us to draw any more ticks, revert
   to edge labelling if that is what the user requested. */
      if( !useint && !labelling ) {
         labelat[ 0 ] = AST__BAD;
         labelat[ 1 ] = AST__BAD;
         edgeticks = EdgeLabels( this, 0, grid, cdata, 1, method, class, status );
      }
   }

/* See if a border is required. By default, a border is drawn only when
   using exterior labelling. */
   if( astTestBorder( this ) ) {
      border = astGetBorder( this );
   } else {
      border = edgeticks;
   }

/* See if the Units string is to be inluded in the label. */
   dounits[ 0 ] =  astGetLabelUnits( this, 0 );
   dounits[ 1 ] =  astGetLabelUnits( this, 1 );

/* The rest is not done if no output is required. */
   if( ink ) {

/* Draw tick marks (major and minor). */
      DrawTicks( this, grid, drawgrid, labelat, gap, method, class, status );

/* If required, ensure that curves through the tick marks have been drawn */
      DrawAxis( this, grid, labelat, gap, method, class, status );

/* If required, draw a curve around the edge of the area containing valid
   physical coordinates. */
      if( border ) (void) astBorder( this );

/* Draw the numerical labels at the major tick values. */
      Labels( this, grid, cdata, gap, labelat, method, class, status );

/* Draw the textual labels for each axis and a title. */
      TextLabels( this, edgeticks, dounits, method, class, status );
   }

/* Ensure all lines are flushed to the graphics system. */
   Fpoly( this, method, class, status );

/* Store the actual values used for all attributes which have dynamic
   defaults. Check the global status to ensure the pointer "grid" can be
   used without the possibility of a segmentation violation. */
   for( axis = 0; axis < 2 && astOK ; axis++ ) {
      SetUsedLogTicks( this_nd, axis, astGetLogTicks( this, axis ), status );
      SetUsedLogLabel( this_nd, axis, astGetLogLabel( this, axis ), status );

      if( astGetLogTicks( this, axis ) ) {
         SetUsedLogGap( this_nd, axis, gap[ axis ], status );
      } else {
         SetUsedGap( this_nd, axis, gap[ axis ], status );
      }
      SetUsedCentre( this_nd, axis, cen[ axis ], status );
      SetUsedEdge( this_nd, axis, astGetEdge( this, axis ), status );
      SetUsedLabelAt( this_nd, axis, labelat[ axis ], status );
      SetUsedLabelUnits( this_nd, axis, dounits[ axis ], status );

/* If explicit minor tick values were supplied using astSetTickValues,
   then set MinTick to the average number of minor tick divisions per major
   tick division. */
      if( grid[ axis ]->minticks ) {
         SetUsedMinTick( this_nd, axis,
                         ( grid[ axis ]->nminor + grid[ axis ]->nmajor )/
                         ( grid[ axis ]->nmajor - 1 ), status );
      } else {
         SetUsedMinTick( this_nd, axis, grid[ axis ]->nminor, status );
      }

      if( astTestTextLab( this, axis ) ) {
         SetUsedTextLab( this_nd, axis, astGetTextLab( this, axis ), status );
      } else {
         SetUsedTextLab( this_nd, axis, edgeticks, status );
      }

      if( astTestMajTickLen( this, axis ) ) {
         SetUsedMajTickLen( this_nd, axis, astGetMajTickLen( this, axis ), status );
      } else {
         SetUsedMajTickLen( this_nd, axis, drawgrid ? 0.0 :
                                           astGetMajTickLen( this, axis ), status );
      }

   }

   SetUsedGrid( this_nd, drawgrid, status );
   SetUsedLabelling( this_nd, edgeticks ? 0 : 1, status );
   SetUsedBorder( this_nd, border, status );

/* Free the memory used to hold information about the curves. */
   cdata = CleanCdata( cdata, status );

/* Free the memory used to hold information about the tick marks. */
   grid = CleanGrid( grid, status );

/* If required clear attributes. */
   if( clredge ) {
      astClearEdge( this, 0 );
      astClearEdge( this, 1 );
   }

   if( !logticksset[ 0 ] ) astClearLogTicks( this, 0 );
   if( !logticksset[ 1 ] ) astClearLogTicks( this, 1 );
   if( !loglabelset[ 0 ] ) astClearLogLabel( this, 0 );
   if( !loglabelset[ 1 ] ) astClearLogLabel( this, 1 );

/* Restore the original value of the Clip attribute. */
   if( clip != -1 ) astSetClip( this, clip );

/* Free the 2D Plot. */
   this = astAnnul( this );

/* Restore the original value of the flag which says whether graphical
   escape sequences should be incldued in any returned text strings. */
   astEscapes( escs );

/* Copy the total bounding box to the box which is returned by
   astBoundingBox. */
   if( !Boxp_freeze ){
      Boxp_lbnd[ 0 ] = Box_lbnd[ 0 ];
      Boxp_lbnd[ 1 ] = Box_lbnd[ 1 ];
      Boxp_ubnd[ 0 ] = Box_ubnd[ 0 ];
      Boxp_ubnd[ 1 ] = Box_ubnd[ 1 ];
   }

/* Return. */
   return;

}

static void GridLine( AstPlot *this, int axis, const double start[],
                      double length, int *status ){
/*
*++
*  Name:
c     astGridLine
f     AST_GRIDLINE

*  Purpose:
*     Draw a grid line (or axis) for a Plot.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astGridLine( AstPlot *this, int axis, const double start[],
c                       double length )
f     CALL AST_GRIDLINE( THIS, AXIS, START, LENGTH, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function draws a curve in the physical coordinate system of
f     This routine draws a curve in the physical coordinate system of
*     a Plot by varying only one of the coordinates along the length
*     of the curve. It is intended for drawing coordinate axes,
*     coordinate grids, and tick marks on axes (but note that these
c     are also available via the more comprehensive astGrid function).
f     are also available via the more comprehensive AST_GRID routine).
*
*     The curve is transformed into graphical coordinate space for
*     plotting, so that a straight line in physical coordinates may
*     result in a curved line being drawn if the Mapping involved is
*     non-linear. Any discontinuities in the Mapping between physical
*     and graphical coordinates are catered for, as is any
c     clipping established using astClip.
f     clipping established using AST_CLIP.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     axis
f     AXIS = INTEGER (Given)
*        The index of the Plot axis whose physical coordinate value is
*        to be varied along the length of the curve (all other
*        coordinates will remain fixed). This value should lie in the
*        range from 1 to the number of Plot axes (Naxes attribute).
c     start
f     START( * ) = DOUBLE PRECISION (Given)
*        An array, with one element for each axis of the Plot, giving
*        the physical coordinates of the start of the curve.
c     length
f     LENGTH = DOUBLE PRECISION (Given)
*        The length of curve to be drawn, given as an increment along
*        the selected physical axis. This may be positive or negative.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
c     - No curve is drawn if the "start" array contains any
c     coordinates with the value AST__BAD, nor if "length" has this value.
f     - No curve is drawn if the START array contains any
f     coordinates with the value AST__BAD, nor if LENGTH has this value.
*     - An error results if the base Frame of the Plot is not 2-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*--
*/
/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   int naxes;              /* No. of axes in the base Frame */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astGridLine";
   class = astGetClass( this );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Initialise the bounding box for primatives produced by this call. */
   if( !Boxp_freeze ) {
      Boxp_lbnd[ 0 ] = FLT_MAX;
      Boxp_lbnd[ 1 ] = FLT_MAX;
      Boxp_ubnd[ 0 ] = FLT_MIN;
      Boxp_ubnd[ 1 ] = FLT_MIN;
   }

/* Validate the axis index, converting the axis index to be zero-based. */
   (void) astValidateAxis( this, axis - 1, 1, method );

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Draw the curve. The break information is stored in an external structure
   where it can be accessed by public methods which return information
   about the most recently drawn curve. */
   AxPlot( this, axis - 1, start, length, 1, &Curve_data, method, class, status );

/* Ensure all lines are flushed to the graphics system. */
   Fpoly( this, method, class, status );
}

static TickInfo **GridLines( AstPlot *this, double *cen, double *gap,
                             int *inval, const char *method, const char *class, int *status ){
/*
*  Name:
*     GridLines

*  Purpose:
*     Obtain information desribing the major tick values within the plotting
*     area.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     TickInfo **GridLines( AstPlot *this, double *cen, double *gap,
*                           int *inval, const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     A pointer is returned which points to an array of two pointers. Each
*     of these pointers points to a TickInfo structure which holds
*     information about the ticks on a single axis. These structures,
*     together with the array holding the two pointers, should be released
*     when no longer needed using CleanGrid.

*  Parameters:
*     this
*        The Plot.
*     cen
*        A pointer to an array holding axis values at which to put a single
*        central tick. Other ticks are placed evenly on either side of this
*        tick. If AST__BAD is provided, a value will be used which would put a
*        tick at an axis value of zero.
*     gap
*        A pointer to an array holding the gaps between ticks required on
*        each axis. If this is AST__BAD a suitable default value will be used
*        and returned in place of the AST__BAD value.
*     inval
*        A pointer to a location at which to return a flag indicating if
*        any invalid physical coordinates were encountered while deciding on
*        the tick values.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to an array of two TickInfo pointers.

*  Notes:
*     -  This function assumes that the physical coordinate system is 2
*     dimensional, and it should not be used if this is not the case.
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned.
*/

/* Local Variables: */
   AstFrame *fr;          /* Pointer to current Frame */
   GetTicksStatics *statics = NULL; /* Pointer to static data for GetTicks */
   TickInfo **info;       /* Returned array of two TickInfo pointers */
   double *lengths;       /* Pointer to lengths of each curve section */
   double *starts;        /* Pointer to start of each curve section */
   double *ticks;         /* Pointer to tick mark values */
   double bot;            /* Lowest axis value to display */
   double end;            /* Axis value at end of curve section */
   double tmp;            /* Temp storage */
   double top;            /* Highest axis value to display */
   int i;                 /* Tick mark index */
   int j;                 /* Axis index */
   int k;                 /* Section index */
   int logticks[ 2 ];     /* Uses logarithmicaly spaced tick marks? */
   int nticks;            /* Number of tick marks */

/* Check the global status. */
   if( !astOK ) return NULL;

/* Get memory to hold two TickInfo pointers. */
   info = (TickInfo **) astMalloc( 2*sizeof( TickInfo *) );

/* If succesfull... */
   if( astOK ){

/* Initialise the two pointers. */
      info[ 0 ] = NULL;
      info[ 1 ] = NULL;

/* Obtain the tick mark values, and the corresponding formatted labels for
   each axis. */
      for( j = 0; j < 2; j++ ){
         info[ j ] = TickMarks( this, j, cen + j, gap + j, inval,
                                &statics, method, class, status );
         logticks[ j ] = astGetLogTicks( this, j );
      }

/* Release the resources allocated in the first call to TickMarks. */
      for( j = 0; j < 2; j++ ){
         (void) TickMarks( NULL, j, NULL, gap, NULL, &statics, method, class,
                           status );
      }

/* Each major tick value for axis "j" may be marked with a curve parallel
   to axis "1-j" drawn across the entire plotting area. We need to decide
   where to start drawing this curve and how long it should be. We can
   simply use the minimum value on axis "1-j" together with the tick value
   on axis "j" to define the starting position. The length could be taken
   as the difference between the maximum and minimum values on axis "1-j".
   However, this may not be right in some situations. For instance if the
   plotting area covers a small range of Right Ascension from 23:59:59 to
   00:00:01. Using the difference between the maximum and minimum values
   to give the length of the curve would result in the curve starting at
   00:00:00 (the minimum axis value) and extending for a length of 23:59:59
   (the axis range). To get round this sort of problem, the curve is split
   up into sections with lengths and starting positions determined by the
   tick mark values on axis "1-j". The first section starts at the minimum
   axis value and extends upto the first missing tick mark (in the RA
   example, this would be at 00:00:01). Subsequent sections starts at the
   next tick mark (23:59:59 in the RA example) and extends upto the next
   missing tick mark, or the last tick mark if none are missing. */

/* Get the current frame. */
      fr = astGetFrame( this, AST__CURRENT );

/* If either axis has log tick spacing, use the simple approach which
   assumes that each curve has only one section. */
      if( logticks[ 0 ] || logticks[ 1 ] ) {

/* Find the start and length of the curve for each tick mark on axis "j". */
         for( j = 0; j < 2 && astOK; j++ ){

/* Find the axis range to display on the other axis. */
            bot = astGetBottom( fr, 1 - j );
            top = astGetTop( fr, 1 - j );
            if( bot > top ) {
               tmp = top;
               top = bot;
               bot = tmp;
            }

/* Get a pointer to the major tick mark values on the other axis ("1-j"),
   together with the number of them. */
            ticks = info[ 1 - j ]->ticks;
            nticks = info[ 1 - j ]->nmajor;

/* Reserve memory to hold the starts and lengths of each section of the
   grid line marking the major ticks on the axis "j". There will only be
   one section. */
            starts = (double *) astMalloc( sizeof(double) );
            lengths = (double *) astMalloc( sizeof(double) );
            info[ j ]->start = starts;
            info[ j ]->length = lengths;

/* Check that the pointers can be used. */
            if( astOK ) {

/* The section starts one gap below the first tick, and ends one gap above
   the first tick. Limit both to the displayed range of the axis. */
               if( logticks[ 1 - j ] ) {
                  starts[ 0 ] = astMIN( top, astMAX( bot, ticks[ 0 ]/gap[ 1 - j ] ) );
                  end = astMIN( top, astMAX( bot, ticks[ nticks - 1 ]*gap[ 1 - j ] ) );
               } else {
                  starts[ 0 ] = astMIN( top, astMAX( bot, ticks[ 0 ] - gap[ 1 - j ] ) );
                  end = astMIN( top, astMAX( bot, ticks[ nticks - 1 ] + gap[ 1 - j ] ) );
               }

/* Store the length of the section. */
               lengths[ 0 ] = end - starts[ 0 ];

/* Store the number of sections in the returned structure. */
               info[ 0 ]->nsect = 1;

            }
         }

/* If both axes have linear tick spacing, use the complete approach. */
      } else {

/* Find the start and length of each section of the curve for each tick
   mark on axis "j". */
         for( j = 0; j < 2 && astOK; j++ ){

/* Find the axis range to display on the other axis. */
            bot = astGetBottom( fr, 1 - j );
            top = astGetTop( fr, 1 - j );
            if( bot > top ) {
               tmp = top;
               top = bot;
               bot = tmp;
            }

/* Get a pointer to the major tick mark values on the other axis ("1-j"),
   together with the number of them. */
            ticks = info[ 1 - j ]->ticks;
            nticks = info[ 1 - j ]->nmajor;

/* Reserve memory to hold the starts and lengths of each section of the
   grid line marking the major ticks on the axis "j". The allocated
   arrays are the largest that could possibly be needed (i.e. if every
   tick mark starts a new section). */
            starts = (double *) astMalloc( sizeof(double)*(size_t) nticks );
            lengths = (double *) astMalloc( sizeof(double)*(size_t) nticks );
            info[ j ]->start = starts;
            info[ j ]->length = lengths;

/* Check that the pointers can be used. */
            if( astOK ) {

/* Loop round each of the major tick marks on axis "1-j". */
               k = 0;
               i = 0;
               while( i < nticks ){

/* Record the start of the next section of the grid lines. */
                  starts[ k ] = ticks[ i++ ];

/* Tick marks should be regularly spaced by the values in "gap". Check each
   tick mark until a missing tick mark is  found. The section ends at the
   start of the gap. */
                  while( i < nticks &&
                         ( ticks[ i ] - ticks[ i - 1 ] ) < 1.5*gap[ 1 - j ] ) i++;

/* Record the length of the section. */
                  lengths[ k ] = ticks[ i - 1 ] - starts[ k ];

/* The section is extended at start and end by one gap in order to "cover
   up the joins". Limit this to the displayed range of the axis. */
                  starts[ k ] -= gap[ 1 - j];
                  lengths[ k ] += 2.0*gap[ 1 - j ];

/* Limit the start and end to the displayed range of the axis. */
                  end = starts[ k ] + lengths[ k ];
                  starts[ k ] = astMIN( top, astMAX( bot, starts[ k ] ) );
                  lengths[ k ] = astMIN( top, astMAX( bot, end ) ) - starts[ k ];

/* Increment the number of sections. */
                  k++;
               }

/* Store the number of sections in the returned structure. */
               info[j]->nsect = k;

            }
         }
      }

/* Annull the current frame. */
      fr = astAnnul( fr );

   }

/* If an error has occurred, clean up the returned TickInfo structures. */
   if( !astOK ) info = CleanGrid( info, status );

/* Return. */
   return info;

}

void astGrfAttrs_( AstPlot *this, int id, int set, int prim, const char *method, const char *class, int *status ){
/*
*+
*  Name:
*     astGrfAttrs

*  Purpose:
*     Establish values for the graphics attributes for a given object.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     void astGrfAttrs( AstPlot *this, int id, int set, int prim, const char *method, const char *class )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function should be called with "set=1" to establish the correct
*     graphics attributes prior to drawing specific graphical objects. Once
*     the object has been drawn, it should be called again with "set=0" to
*     re-establish the original graphics attributes.
*
*     NOTE, each type of graphical object identified by "id" should be
*     drawn entirely by calls to just one of GMark, GText or GLine
*     as indicated by argument "prim".

*  Parameters:
*     this
*        A pointer to the Plot.
*     id
*        An integer specifying the graphical object to be drawn.
*     set
*        If non-zero then the attributes for the specified object are set
*        to the values indicated by the corresponding Plot attributes,
*        and the current values are saved in a static array. If zero, then
*        the values are set to the values stored in the static array.
*     prim
*        Indicates the sort of graphics primative used to draw the
*        object. This must be one of (defined in grf.h) :
*
*           GRF__LINE
*           GRF__MARK
*           GRF__TEXT
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.

*  Notes:
*     -  This function should always be called in pairs with set=1 on the
*     first call and set=0 on the second call.
*     -  If a pair of calls is nested within another pair of calls, the
*     inner pair has no effect.
*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   double *attr;           /* Pointer to the next attribute value */
   double dval;            /* Floating point attribute value */
   int ival;               /* Integer attribute value */

/* Check the global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Set up a pointer to the next element in "grfattrs_attrs". */
   attr = grfattrs_attrs;

/* If we are setting new values, increment the nesting level, otherwise
   decrement it. */
   if( set ){
      grfattrs_nesting++;
   } else {
      grfattrs_nesting--;
   }

/* If we are changing any line attributes, ensure all lines are flushed to
   the graphics system. */
   if( prim == GRF__LINE ) Fpoly( this, method, class, status );

/* First deal with cases where we are establishing new values for the
   graphics attributes by setting them to the values of the corresponding
   Plot attributes. Only do this if we are at nesting level one. */
   if( set && grfattrs_nesting == 1 ){

/* See if a value has been set in the Plot for the line style attribute for
   the specified object, If so, use the value. */
      if( TestUseStyle( this, id, status ) ) {
         ival = GetUseStyle( this, id, status );

/* Save the current value, and establish the new value. */
         GAttr( this, GRF__STYLE, (double) ival, attr++, prim, method,
                class, status );

/* If no style was specified, retain the current value. Indicate that no
   new value has been established by setting the old value bad. */
      } else {
         *(attr++) = AST__BAD;
      }

/* Do the same for the line width attribute. */
      if( TestUseWidth( this, id, status ) ){
         dval = GetUseWidth( this, id, status );
         GAttr( this, GRF__WIDTH, dval, attr++, prim, method, class, status );
      } else {
         *(attr++) = AST__BAD;
      }

/* Do the same for the character size attribute. */
      if( TestUseSize( this, id, status ) ) {
         dval = GetUseSize( this, id, status );
         GAttr( this, GRF__SIZE, dval, attr++, prim, method, class, status );
      } else {
         *(attr++) = AST__BAD;
      }

/* Do the same for the character font attribute. */
      if( TestUseFont( this, id, status ) ){
         ival = GetUseFont( this, id, status );
         GAttr( this, GRF__FONT, (double) ival, attr++, prim, method, class, status );
      } else {
         *(attr++) = AST__BAD;
      }

/* Do the same for the colour attribute. */
      if( TestUseColour( this, id, status ) ) {
         ival = GetUseColour( this, id, status );
         GAttr( this, GRF__COLOUR, (double) ival, attr++, prim, method,
                class, status );
      } else {
         *(attr++) = AST__BAD;
      }

   }

/* Now deal with cases where we are re-establishing old values saved on a
   previous call to this function. Only do this if we are at nesting
   level zero. */
   if( !set && !grfattrs_nesting ){
      GAttr( this, GRF__STYLE, *(attr++), NULL, prim, method, class, status );
      GAttr( this, GRF__WIDTH, *(attr++), NULL, prim, method, class, status );
      GAttr( this, GRF__SIZE, *(attr++), NULL, prim, method, class, status );
      GAttr( this, GRF__FONT, *(attr++), NULL, prim, method, class, status );
      GAttr( this, GRF__COLOUR, *(attr++), NULL, prim, method, class, status );
   }

/* Return. */
   return;

}

static int GVec( AstPlot *this, AstMapping *mapping, double *phy,
                 int axis, double delta, AstPointSet **pset1,
                 AstPointSet **pset2, double *gx, double *gy,
                 double *dx, double *dy, int *flag, const char *method,
                 const char *class, int *status ){
/*
*  Name:
*     GVec

*  Purpose:
*     Returns a unit vector parallel to a physical axis at a given point.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GVec( AstPlot *this, AstMapping *mapping, double *phy,
*               int axis, double delta, AstPointSet **pset1,
*               AstPointSet **pset2, double *gx, double *gy,
*               double *dx, double *dy, int *flag, const char *method,
*               const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function returns a unit vector (in the graphics coordinate
*     system) in the positive direction of the specified physical axis,
*     at the given physical position. It works by transforming the given
*     physical position, together with another very close position, and
*     returning the vector between them. It is possible for a
*     discontinuity to occur between these two close positions,
*     resulting in a very large meaningless vector prior to
*     normalisation. For this reason two vectors are found, one joining
*     the given position to a close position higher up the axis, and one
*     joining a close position lower down the axis to the given position.
*     If these two vectors differ in magnitude by a large factor, then
*     the shorter of the two vectors is normalised and returned.
*     Otherwise, the vector which is closest in direction to the vector
*     supplied in [dx,dy] is returned. The returned vector is reversed if
*     necessary so that it always points in the positive direction of the
*     axis.
*
*     If neither of the two vectors can be found (i.e. if the graphics
*     coordinates are bad, or coincident), then the vector supplied in
*     [dx,dy] is returned unchanged, and a function value of zero is
*     returned. Otherwise, a function value of one is returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     mapping
*        Pointer to the Mapping from the base Frame of the Plot to the
*        current Frame.
*     phy
*        Pointer to an array holding the coordinates in the current Frame
*        of the Plot at which the tangent vector is required.
*     axis
*        The index of the axis within the current Frame for which the
*        tangent vector is required.
*     delta
*        The increment in the axis value to use between positions defining
*        the vectors.
*     pset1
*        A pointer to a place at which to store a pointer to a PointSet
*        holding current Frame coordinates. This PointSet pointer should
*        be supplied as NULL on the first call to this function, resulting
*        in a new PointSet being created and a pointer to it returned.
*        Subsequent calls to this function shopuld retain the pointer
*        returned by the first call. The PointSet pointer should be
*        annulled using astAnnul when no longer needed.
*     pset2
*        A pointer to a place at which to store a pointer to a PointSet
*        holding base Frame coordinates. This PointSet is managed in the
*        same way as "pset1".
*     gx
*        A pointer to a double in which to return the graphics X
*        coordinate of the position supplied by "phy".
*     gy
*        A pointer to a double in which to return the graphics Y
*        coordinate of the position supplied by "phy".
*     dx
*        A pointer to a double in which to return the X component
*        of the unit tangent vector. This should be supplied holding a
*        "default" unit vector which is left unchanged if no new vector
*        can be found.
*     dy
*        A pointer to a double in which to return the Y component
*        of the unit tangent vector. This should be supplied holding a
*        "default" unit vector which is left unchanged if no new vector
*        can be found.
*     flag
*        A pointer to an int in which to return a flag indicating which
*        of the two vectors was returned. Zero is returned if the vector
*        was estimated by moving in a positive direction along the axis
*        from the position supplied by "phy". One is returned if the vector
*        was estimated by moving in a negative direction along the axis
*        from the position supplied by "phy" (in this case the returned
*        vector will have been negated so that it refers to the positive
*        direction).
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One is returned if the vector was found succesfully, Zero is returned
*     if the vector could not be estimated for any reason. No error is
*     reported if the failure was due to the nature of the mapping.

*  Notes:
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned.
*/

/* Local Variables: */
   double dd1;        /* Length of positive vector */
   double dd2;        /* Length of negative vector */
   double dx1;        /* X component of positive vector */
   double dx2;        /* X component of negative vector */
   double dy1;        /* Y component of positive vector */
   double dy2;        /* Y component of negative vector */
   double **ptr1;     /* Pointers to physical coordinate data */
   double **ptr2;     /* Pointers to graphics coordinate data */
   int i;             /* Axis index */
   int nphy;          /* No. of axes in current (physical) Frame */
   int ret;           /* Was a vector estimated succesfully? */

/* Check the global status. */
   if( !astOK ) return 0;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   dx1 = 0.0;
   dx2 = 0.0;
   dy1 = 0.0;
   dy2 = 0.0;

/* Initialise the returned value to indicate that the vector can not
   be found. */
   ret = 0;

/* Get the number of physical coordinates from the mapping. */
   nphy = astGetNout( mapping );

/* If no PointSets have been supplied, create some now. PointSet 1
   contains physical coordinates, PointSet 2 contains graphics
   coordinates. */
   if( !(*pset1) ) *pset1 = astPointSet( 3, nphy, "", status );
   if( !(*pset2) ) *pset2 = astPointSet( 3, 2, "", status );

/* Get pointers to the PointSet data. */
   ptr1 = astGetPoints( *pset1 );
   ptr2 = astGetPoints( *pset2 );

/* Check the PointSets can be used. */
   if( astOK ){

/* Store the physical coordinates of three close points on a curve
   parallel to the given axis, with the centre point at the given
   position. */
      for( i = 0; i < nphy; i++ ){
         ptr1[ i ][ 0 ] = phy[ i ];
         ptr1[ i ][ 1 ] = phy[ i ];
         ptr1[ i ][ 2 ] = phy[ i ];
      }

      if( phy[ axis ] != AST__BAD ){
         ptr1[ axis ][ 0 ] = phy[ axis ] - delta;
         ptr1[ axis ][ 2 ] = phy[ axis ] + delta;
      }

/* Find the corresponding graphics coordinates. */
      (void) Trans( this, NULL, mapping, *pset1, 0, *pset2, 0, method, class, status );

/* Check the central position is OK. */
      *gx = ptr2[ 0 ][ 1 ];
      *gy = ptr2[ 1 ][ 1 ];
      if( astOK && *gx != AST__BAD && *gy != AST__BAD ){

/* Get the unit vector between the central position and the position at
   the higher physical axis value. Also get the length of the vector
   joining the two positions. */
         if( ptr2[ 0 ][ 2 ] != AST__BAD && ptr2[ 1 ][ 2 ] != AST__BAD ){
            dx1 = ptr2[ 0 ][ 2 ] - *gx;
            dy1 = ptr2[ 1 ][ 2 ] - *gy;
            dd1 = dx1*dx1 + dy1*dy1;

            if( dd1 > 0.0 ) {
               dd1 = sqrt( dd1 );
               dx1 /= dd1;
               dy1 /= dd1;
            } else {
               dd1 = AST__BAD;
            }

         } else {
            dd1 = AST__BAD;
         }

/* Do the same for the position with lower physical axis value,
   reversing the direction of the vector so that it refers to the
   positive direction. */
         if( ptr2[ 0 ][ 0 ] != AST__BAD && ptr2[ 1 ][ 0 ] != AST__BAD ){
            dx2 = *gx - ptr2[ 0 ][ 0 ];
            dy2 = *gy - ptr2[ 1 ][ 0 ];
            dd2 = dx2*dx2 + dy2*dy2;

            if( dd2 > 0.0 ) {
               dd2 = sqrt( dd2 );
               dx2 /= dd2;
               dy2 /= dd2;
            } else {
               dd2 = AST__BAD;
            }

         } else {
            dd2 = AST__BAD;
         }

/* Only overwrite the supplied vector if at least one of the two tangent
   vectors was defined. */
         if( dd1 != AST__BAD || dd2 != AST__BAD ){

/* If the first vector was not defined, return the second. */
            if( dd1 == AST__BAD ){
               *dx = dx2;
               *dy = dy2;
               *flag = 1;
               ret = 1;

/* If the second vector was not defined, return the first. */
            } else if( dd2 == AST__BAD ){
               *dx = dx1;
               *dy = dy1;
               *flag = 0;
               ret = 1;

/* If the first vector is much longer than the second, return the
   second. */
            } else if( dd1 > 100.0*dd2 ){
               *dx = dx2;
               *dy = dy2;
               *flag = 1;
               ret = 1;

/* If the second vector is much longer than the first, return the
   first. */
            } else if( dd2 > 100.0*dd1 ){
               *dx = dx1;
               *dy = dy1;
               *flag = 0;
               ret = 1;

/* If both vectors are defined and of comparable length, return the
   vector which is most nearly parallel to the supplied vector. Note, we
   assume that the supplied vector [dx,dy] is a unit vector. */
            } else if( *dx != AST__BAD && *dx != AST__BAD ){
               if( ( dx1*(*dx) + dy1*(*dy) )/dd1 >
                   ( dx2*(*dx) + dy2*(*dy) )/dd2 ){
                  *dx = dx1;
                  *dy = dy1;
                  *flag = 0;
                  ret = 1;

               } else {
                  *dx = dx2;
                  *dy = dy2;
                  *flag = 1;
                  ret = 1;
               }

/* If no vector was supplied, return the shorter of the two vectors. */
            } else if( dd1 < dd2 ){
               *dx = dx1;
               *dy = dy1;
               *flag = 0;
               ret = 1;

            } else {
               *dx = dx2;
               *dy = dy2;
               *flag = 1;
               ret = 1;

            }

         }

      }

   }

/* Return the answer. */
   return ret;

}

static int HasEscapes( const char *text, int *status ) {
/*
*  Name:
*     HasEscapes

*  Purpose:
*     Check if a text string contains any escape sequences.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int HasEscapes( const char *text, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function checks if a text string contains any escape sequences
*     (see attribute Escape).

*  Parameters:
*     text
*        The text to check.
*     status
*        Pointer to the inherited status variable.

*  Returned:
*     Non-zero if any escape sequences are found in the text. Zero
*     otherwise.

*/

/* Local Variables: */
   int result;
   int type;
   int value;
   int nc;

/* Initialise. */
   result = 0;

/* Check the global error status and the supplied pointer. */
   if ( !astOK || ! text ) return result;

/* Does the string begin with an escape sequence? */
   if( astFindEscape( text, &type, &value, &nc ) ){
      result = 1;

/* If not, there must be an escape sequence later in the string if the
   number of characters skipped by the above call to astFindEscape is less
   than the length of the string. */
   } else if( nc < strlen( text ) ) {
      result = 1;
   }

/* Return the result. */
   return result;
}

static int IdFind( int id, int nax, int *id1, int *id2, int *id3, int *status ) {
/*
*  Name:
*     IdFind

*  Purpose:
*     Find the numerical identifiers to use for a given identifier.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int IdFind( int id, int nax, int *id1, int *id2, int *id3, int *status  )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied integer should be a numerical identifier for a
*     graphical element of a plot (AST__MARKS_ID, AST__CURVES_ID, etc), or a
*     "psuedo-identifier" which represents two other genuine identifiers.
*     If the supplied value is a genuine identifier then it is returned
*     in *id1, and *id2 is returned equal to -1. If the supplied value
*     is a pseudo-identifier then the two corresponding genuine
*     identifiers are returned in *id1 and *id2

*     For instance, if "id" is AST__AXIS1_ID (a genuine id), then *id1 is
*     returned equal to AST__AXIS1_ID and *id2 is returned equal to -1. If
*     "id" is AST__AXES_ID (a pseudo-identifier), then *id1 is returned equal
*     to AST__AXIS1_ID and *id2 is returned equal to AST__AXIS2_ID.

*     Genuine identifiers all have values which are less than the value
*     of AST__NPID. Pseudo-identifiers have values which are greater than
*     or equal to the value of AST__NPID.

*  Parameters:
*     id
*        The supplied identifier (genuine or pseudo).
*     nax
*        The number of axes spanning graphics space (2 or 3).
*     id1
*        Pointer to the int at which to return the first genuine
*        identifier corresponding to "id".
*     id2
*        Pointer to the int at which to return the second genuine
*        identifier corresponding to "id" (or -1 if "id" is a genuine
*        identifier).
*     id3
*        Pointer to the int at which to return the third genuine
*        identifier corresponding to "id" (or -1 if "id" has no third
*        genuine identifier).
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The number of genuine identifiers corresponding to the supplied
*     (possibly Pseudo-) identifier. This will be in the range 1 to 3.

*/

/* Local Variables: */
   int ret;

/* Initialise returned values. */
   *id1 = id;
   *id2 = -1;
   *id3 = -1;
   ret = 0;

/* Check the local error status. */
   if ( !astOK ) return ret;

/* Assume a genuine identifier was supplied. */
   ret = 1;

/* Check against all known pseudo-identifier. */
   if( id == AST__AXES_ID ) {
      ret = nax;
      *id1 = AST__AXIS1_ID;
      *id2 = AST__AXIS2_ID;
      if( nax == 3 ) *id3 = AST__AXIS3_ID;

   } else if( id == AST__GRIDLINE_ID ) {
      ret = nax;
      *id1 = AST__GRIDLINE1_ID;
      *id2 = AST__GRIDLINE2_ID;
      if( nax == 3 ) *id3 = AST__GRIDLINE3_ID;

   } else if( id == AST__NUMLABS_ID ) {
      ret = nax;
      *id1 = AST__NUMLAB1_ID;
      *id2 = AST__NUMLAB2_ID;
      if( nax == 3 ) *id3 = AST__NUMLAB3_ID;

   } else if( id == AST__TEXTLABS_ID ) {
      ret = nax;
      *id1 = AST__TEXTLAB1_ID;
      *id2 = AST__TEXTLAB2_ID;
      if( nax == 3 ) *id3 = AST__TEXTLAB3_ID;

   } else if( id == AST__TICKS_ID ) {
      ret = nax;
      *id1 = AST__TICKS1_ID;
      *id2 = AST__TICKS2_ID;
      if( nax == 3 ) *id3 = AST__TICKS3_ID;

   } else if( id >= AST__NPID ) {
      astError( AST__INTER, "AST internal programming error - "
                "function IdFind in class Plot does not yet support "
                "pseudo-identifier value %d", status, id );
   }

/* Return the answer. */
   return ret;

}

void astInitPlotVtab_(  AstPlotVtab *vtab, const char *name, int *status ) {
/*
*+
*  Name:
*     astInitPlotVtab

*  Purpose:
*     Initialise a virtual function table for a Plot.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     void astInitPlotVtab( AstPlotVtab *vtab, const char *name )

*  Class Membership:
*     Plot vtab initialiser.

*  Description:
*     This function initialises the component of a virtual function
*     table which is used by the Plot class.

*  Parameters:
*     vtab
*        Pointer to the virtual function table. The components used by
*        all ancestral classes will be initialised if they have not already
*        been initialised.
*     name
*        Pointer to a constant null-terminated character string which contains
*        the name of the class to which the virtual function table belongs (it
*        is this pointer value that will subsequently be returned by the Object
*        astClass function).
*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstFrameSetVtab *fset;        /* Pointer to FrameSet component of Vtab */
   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
   AstMappingVtab *mapping;      /* Pointer to Mapping component of Vtab */

/* Check the local error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Initialize the component of the virtual function table used by the
   parent class. */
   astInitFrameSetVtab( (AstFrameSetVtab *) vtab, name );

/* Store a unique "magic" value in the virtual function table. This will be
   used (by astIsAPlot) to determine if an object belongs to this class.
   We can conveniently use the address of the (static) class_init variable to
   generate this unique value. */
   vtab->id.check = &class_check;
   vtab->id.parent = &(((AstFrameSetVtab *) vtab)->id);

/* Initialise member function pointers. */
/* ------------------------------------ */
/* Store pointers to the member functions (implemented here) that provide
   virtual methods for this class. */
   vtab->BBuf = BBuf;
   vtab->Border = Border;
   vtab->BoundingBox = BoundingBox;
   vtab->ClearGrid = ClearGrid;
   vtab->ClearTol = ClearTol;
   vtab->Clip = Clip;
   vtab->CopyPlotDefaults = CopyPlotDefaults;
   vtab->Curve = Curve;
   vtab->CvBrk = CvBrk;
   vtab->EBuf = EBuf;
   vtab->GenCurve = GenCurve;
   vtab->GetDrawnTicks = GetDrawnTicks;
   vtab->GetGrid = GetGrid;
   vtab->GetTol = GetTol;
   vtab->GrfPop = GrfPop;
   vtab->GrfPush = GrfPush;
   vtab->GrfSet = GrfSet;
   vtab->GrfWrapper = GrfWrapper;
   vtab->Grid = Grid;
   vtab->GridLine = GridLine;
   vtab->Mark = Mark;
   vtab->Mirror = Mirror;
   vtab->PolyCurve = PolyCurve;
   vtab->RegionOutline = RegionOutline;
   vtab->SetGrid = SetGrid;
   vtab->SetTickValues = SetTickValues;
   vtab->SetTol = SetTol;
   vtab->TestGrid = TestGrid;
   vtab->TestTol = TestTol;
   vtab->Text = Text;

   vtab->ClearTickAll = ClearTickAll;
   vtab->SetTickAll = SetTickAll;
   vtab->GetTickAll = GetTickAll;
   vtab->TestTickAll = TestTickAll;

   vtab->ClearForceExterior = ClearForceExterior;
   vtab->SetForceExterior = SetForceExterior;
   vtab->GetForceExterior = GetForceExterior;
   vtab->TestForceExterior = TestForceExterior;

   vtab->ClearInvisible = ClearInvisible;
   vtab->SetInvisible = SetInvisible;
   vtab->GetInvisible = GetInvisible;
   vtab->TestInvisible = TestInvisible;
   vtab->ClearBorder = ClearBorder;
   vtab->SetBorder = SetBorder;
   vtab->GetBorder = GetBorder;
   vtab->TestBorder = TestBorder;
   vtab->ClearInk = ClearInk;
   vtab->SetInk = SetInk;
   vtab->GetInk = GetInk;
   vtab->TestInk = TestInk;
   vtab->ClearClipOp = ClearClipOp;
   vtab->SetClipOp = SetClipOp;
   vtab->GetClipOp = GetClipOp;
   vtab->TestClipOp = TestClipOp;
   vtab->ClearClip = ClearClip;
   vtab->SetClip = SetClip;
   vtab->GetClip = GetClip;
   vtab->TestClip = TestClip;
   vtab->ClearGrf = ClearGrf;
   vtab->SetGrf = SetGrf;
   vtab->GetGrf = GetGrf;
   vtab->TestGrf = TestGrf;
   vtab->ClearDrawTitle = ClearDrawTitle;
   vtab->SetDrawTitle = SetDrawTitle;
   vtab->GetDrawTitle = GetDrawTitle;
   vtab->TestDrawTitle = TestDrawTitle;
   vtab->ClearLabelUp = ClearLabelUp;
   vtab->SetLabelUp = SetLabelUp;
   vtab->GetLabelUp = GetLabelUp;
   vtab->TestLabelUp = TestLabelUp;
   vtab->ClearLogPlot = ClearLogPlot;
   vtab->SetLogPlot = SetLogPlot;
   vtab->GetLogPlot = GetLogPlot;
   vtab->TestLogPlot = TestLogPlot;
   vtab->ClearLogTicks = ClearLogTicks;
   vtab->SetLogTicks = SetLogTicks;
   vtab->GetLogTicks = GetLogTicks;
   vtab->TestLogTicks = TestLogTicks;
   vtab->ClearLogLabel = ClearLogLabel;
   vtab->SetLogLabel = SetLogLabel;
   vtab->GetLogLabel = GetLogLabel;
   vtab->TestLogLabel = TestLogLabel;
   vtab->ClearDrawAxes = ClearDrawAxes;
   vtab->SetDrawAxes = SetDrawAxes;
   vtab->GetDrawAxes = GetDrawAxes;
   vtab->TestDrawAxes = TestDrawAxes;
   vtab->ClearAbbrev = ClearAbbrev;
   vtab->SetAbbrev = SetAbbrev;
   vtab->GetAbbrev = GetAbbrev;
   vtab->TestAbbrev = TestAbbrev;
   vtab->ClearEscape = ClearEscape;
   vtab->SetEscape = SetEscape;
   vtab->GetEscape = GetEscape;
   vtab->TestEscape = TestEscape;
   vtab->ClearLabelling = ClearLabelling;
   vtab->SetLabelling = SetLabelling;
   vtab->GetLabelling = GetLabelling;
   vtab->TestLabelling = TestLabelling;
   vtab->ClearTextGapType = ClearTextGapType;
   vtab->SetTextGapType = SetTextGapType;
   vtab->GetTextGapType = GetTextGapType;
   vtab->TestTextGapType = TestTextGapType;
   vtab->ClearMajTickLen = ClearMajTickLen;
   vtab->SetMajTickLen = SetMajTickLen;
   vtab->GetMajTickLen = GetMajTickLen;
   vtab->TestMajTickLen = TestMajTickLen;
   vtab->ClearLogGap = ClearLogGap;
   vtab->SetLogGap = SetLogGap;
   vtab->GetLogGap = GetLogGap;
   vtab->TestLogGap = TestLogGap;
   vtab->ClearTitleGap = ClearTitleGap;
   vtab->SetTitleGap = SetTitleGap;
   vtab->GetTitleGap = GetTitleGap;
   vtab->TestTitleGap = TestTitleGap;
   vtab->ClearMinTickLen = ClearMinTickLen;
   vtab->SetMinTickLen = SetMinTickLen;
   vtab->GetMinTickLen = GetMinTickLen;
   vtab->TestMinTickLen = TestMinTickLen;
   vtab->ClearNumLabGap = ClearNumLabGap;
   vtab->SetNumLabGap = SetNumLabGap;
   vtab->GetNumLabGap = GetNumLabGap;
   vtab->TestNumLabGap = TestNumLabGap;
   vtab->ClearTextLabGap = ClearTextLabGap;
   vtab->SetTextLabGap = SetTextLabGap;
   vtab->GetTextLabGap = GetTextLabGap;
   vtab->TestTextLabGap = TestTextLabGap;
   vtab->ClearLabelAt = ClearLabelAt;
   vtab->SetLabelAt = SetLabelAt;
   vtab->GetLabelAt = GetLabelAt;
   vtab->TestLabelAt = TestLabelAt;
   vtab->ClearCentre = ClearCentre;
   vtab->SetCentre = SetCentre;
   vtab->GetCentre = GetCentre;
   vtab->TestCentre = TestCentre;
   vtab->ClearGap = ClearGap;
   vtab->SetGap = SetGap;
   vtab->GetGap = GetGap;
   vtab->TestGap = TestGap;
   vtab->ClearEdge = ClearEdge;
   vtab->SetEdge = SetEdge;
   vtab->GetEdge = GetEdge;
   vtab->TestEdge = TestEdge;
   vtab->ClearNumLab = ClearNumLab;
   vtab->SetNumLab = SetNumLab;
   vtab->GetNumLab = GetNumLab;
   vtab->TestNumLab = TestNumLab;
   vtab->ClearMinTick = ClearMinTick;
   vtab->SetMinTick = SetMinTick;
   vtab->GetMinTick = GetMinTick;
   vtab->TestMinTick = TestMinTick;
   vtab->ClearTextLab = ClearTextLab;
   vtab->SetTextLab = SetTextLab;
   vtab->GetTextLab = GetTextLab;
   vtab->TestTextLab = TestTextLab;
   vtab->ClearLabelUnits = ClearLabelUnits;
   vtab->SetLabelUnits = SetLabelUnits;
   vtab->GetLabelUnits = GetLabelUnits;
   vtab->TestLabelUnits = TestLabelUnits;
   vtab->ClearStyle = ClearStyle;
   vtab->SetStyle = SetStyle;
   vtab->GetStyle = GetStyle;
   vtab->TestStyle = TestStyle;
   vtab->ClearFont = ClearFont;
   vtab->SetFont = SetFont;
   vtab->GetFont = GetFont;
   vtab->TestFont = TestFont;
   vtab->ClearColour = ClearColour;
   vtab->SetColour = SetColour;
   vtab->GetColour = GetColour;
   vtab->TestColour = TestColour;
   vtab->ClearWidth = ClearWidth;
   vtab->SetWidth = SetWidth;
   vtab->GetWidth = GetWidth;
   vtab->TestWidth = TestWidth;
   vtab->ClearSize = ClearSize;
   vtab->SetSize = SetSize;
   vtab->GetSize = GetSize;
   vtab->TestSize = TestSize;
   vtab->GetGrfContext = GetGrfContext;

/* Save the inherited pointers to methods that will be extended, and replace
   them with pointers to the new member functions. */
   object = (AstObjectVtab *) vtab;
   mapping = (AstMappingVtab *) vtab;
   fset = (AstFrameSetVtab *) vtab;

   parent_clearattrib = object->ClearAttrib;
   object->ClearAttrib = ClearAttrib;
   parent_getattrib = object->GetAttrib;
   object->GetAttrib = GetAttrib;
   parent_setattrib = object->SetAttrib;
   object->SetAttrib = SetAttrib;
   parent_testattrib = object->TestAttrib;
   object->TestAttrib = TestAttrib;

#if defined(THREAD_SAFE)
   parent_managelock = object->ManageLock;
   object->ManageLock = ManageLock;
#endif

   parent_transform = mapping->Transform;
   mapping->Transform = Transform;

   parent_removeframe = fset->RemoveFrame;
   fset->RemoveFrame = RemoveFrame;

/* Declare the destructor and copy constructor. */
   astSetDelete( (AstObjectVtab *) vtab, Delete );
   astSetCopy( (AstObjectVtab *) vtab, Copy );

/* Declare the class dump function. */
   astSetDump( vtab, Dump, "Plot", "Provide facilities for 2D graphical output" );

/* If we have just initialised the vtab for the current class, indicate
   that the vtab is now initialised, and store a pointer to the class
   identifier in the base "object" level of the vtab. */
   if( vtab == &class_vtab ) {
      class_init = 1;
      astSetVtabClassIdentifier( vtab, &(vtab->id) );
   }
}

static int Inside( int n, float *cx, float *cy, float x, float y, int *status ){
/*
*  Name:
*     Inside

*  Purpose:
*     See if a given point is inside a 2-d polygon.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Inside( int n, float *cx, float *cy, float x, float y, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function determines if the position given by x and y, is inside
*     or outside the polygon specified by the vertices given in arrays cx
*     and cy.

*  Parameters:
*     n
*        The number of vertices in the polygon.
*     cx
*        A pointer to an array holding the x coordinates at the "n" vertices.
*     cy
*        A pointer to an array holding the y coordinates at the "n" vertices.
*     x
*        The x coordinate of the test point.
*     y
*        The y coordinate of the test point.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A boolean flag indicating if the test point is inside the polygon.

*  Notes:
*     -  The algorithm used only works for convex polygons.
*     -  The polygon is closed by joining the last vertex to the first
*     vertex.
*     -  Zero is returned if an error has occurred.

*/

/* Local Variables: */
   int i;        /* Index of the current vertex */
   int j;        /* Index of the next vertex */
   int ret;      /* Is the test point inside the polygon? */
   int sgn;      /* Which side of the first edge is the test point? */

/* Check the global status. */
   if( !astOK ) return 0;

/* Initialise the returned value to indicate that the point is inside the
   box. */
   ret = 1;

/* Get the sign of the angle between the vector joining vertex 1 to vertex
   0, and the vector joining the test point to vertex zero. */
   if( ( cx[ 1 ] - cx[ 0 ] )*( y - cy[ 0 ] ) >
       ( x - cx[ 0 ] )*( cy[ 1 ] - cy[ 0 ] ) ){
      sgn = 1;
   } else {
      sgn = -1;
   }

/* Check that the remaining test point is on the same side of the remaining
   sides. */
   for( i = 1; i < n; i++ ){

/* Get the index of the next vertex, joining the last vertex up with
   vertex zero. */
      j = i + 1;
      if( j >= n ) j -= n;

/* Get the sign of the angle between the vector joining vertex j to vertex
   i, and the vector joining the test point to vertex i. If the sign is
   opposite to that found for vertex zero, then the test point is outside
   the polygon. Break out of the loop if this is the case. */
      if( ( cx[ j ] - cx[ i ] )*( y - cy[ i ] ) >
          ( x - cx[ i ] )*( cy[ j ] - cy[ i ] ) ){

         if( sgn == -1 ) {
            ret = 0;
            break;
         }

      } else {

         if( sgn == 1 ) {
            ret = 0;
            break;
         }

      }

   }


/* Return the answer. */
   return ret;

}

static void InterpEscape( AstPlot *this, int type, double value, float *x,
                          float *y, float ux, float uy, float rx, float ry,
                          const char *just, float *rise, double nsize,
                          double nstyle, double nwidth, double ncol,
                          double nfont, const char *method, const char *class, int *status ){
/*
*  Name:
*     InterpEscape

*  Purpose:
*     Prepare things for drawing the next part of a string which includes
*     graphics escape sequences.

*  Synopsis:
*     #include "plot.h"
*     void InterpEscape( AstPlot *this, int type, double value, float *x,
*                        float *y, float ux, float uy, float rx, float ry,
*                        const char *just, float *rise, double nsize,
*                        double nstyle, double nwidth, double ncol,
*                        double nfont, const char *method, const char *class, int *status )

*  Description:
*     This function modifies the current graphics attributes, the supplied
*     reference position, in preparation for drawing another sub-string
*     from a string containing graphics escape sequences. The type and
*     value of an escape sequence preceding the substring is supplied.
*     Note, this function ignored escape sequences which represent an
*     escaped percent sign. Such escape sequences are drawn as normal
*     text by the claling function.

*  Parameters:
*     this
*        The plot.
*     type
*        The type of escape sequence. Each type is identified by a symbolic
*        constant defined in grf.h.
*     value
*        The value associated with the escape sequence. All usable values
*        will be positive. A value of -1 shold be supplied if the attribute
*        identified by "type" should be reset to its "normal" value (as
*        established using the astGAttr function, etc).
*     x
*        Pointer to a double holding the x coordinate at the concatenation
*        point. This will be modified on exit if the escape sequence
*        requires it.
*     y
*        Pointer to a double holding the y coordinate at the concatenation
*        point. This will be modified on exit if the escape sequence
*        requires it.
*     ux
*        The x component of the up-vector for the text, in graphics coords.
*        The length of this vector should be equal to the height of normal
*        text drawn with this up-vector.
*     uy
*        The y component of the up-vector for the text. See "ux".
*     rx
*        The x component of the right-vector for the text. The length of this
*        vector should be equal to the height of normal text drawn with the
*        supplied up-vector.
*     ry
*        The y component of the right-vector for the text. see "rx".
*     just
*        The justification being used for each substring.
*     rise
*        Pointer to a float holding the height of the current baseline
*        above the normal baseline, given as a percentage of the height of
*        normal text. May be negative for sub-scripts. May be modified on
*        exit if the escape sequence effects the height of the baseline.
*     nsize
*        The size of normal text.
*     nstyle
*        The style of normal text.
*     nwidth
*        The width of normal text.
*     ncol
*        The colour of normal text.
*     nfont
*        The font of normal text.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   float new_rise;
   float t1, t2;

/* Check the global error status. */
   if ( !astOK ) return;

/* Type GRF__ESSUP: Move the concatenation point in the up direction, and
   update the current baseline height. If the value is -1, then reset the
   baseline to its normal height. */
   if( type == GRF__ESSUP ) {
      if( value > 0 ) {
         *x += 0.01*ux*( value - *rise );
         *y += 0.01*uy*( value - *rise );
         *rise = value;
      } else {
         *x -= 0.01*ux*(*rise);
         *y -= 0.01*uy*(*rise);
         *rise = 0;
      }

/* Type GRF__ESSUB: Move the concatenation point in the down direction, and
   update the current baseline height. If the value is -1, then reset the
   baseline to its normal height. */
   } else if( type == GRF__ESSUB ) {
      if( value > 0 ) {
         *x -= 0.01*ux*( value + *rise );
         *y -= 0.01*uy*( value + *rise );
         *rise = -value;
      } else {
         *x -= 0.01*ux*(*rise);
         *y -= 0.01*uy*(*rise);
         *rise = 0;
      }

/* Type GRF__ESGAP: Move the concatenation point to the right. */
   } else if( type == GRF__ESGAP ) {
      *x += 0.01*rx*value;
      *y += 0.01*ry*value;

/* Type GRF__ESBAC: Move the concatenation point to the left. */
   } else if( type == GRF__ESBAC ) {
      *x -= 0.01*rx*value;
      *y -= 0.01*ry*value;

/* Remember the current horizontal position. */
   } else if( type == GRF__ESH ) {
      this->hmarkx = *x;
      this->hmarky = *y;

/* Go to the previously stored horizontal position. */
   } else if( type == GRF__ESG ) {
      if( this->hmarkx != FLT_MAX && this->hmarky != FLT_MAX ) {
         t1 = ( *x - this->hmarkx )*rx + ( *y - this->hmarky )*ry;
         t2 = rx*rx + ry*ry;
         *x -= rx*t1/t2;
         *y -= ry*t1/t2;
      }

/* Type GRF__ESSIZ: Change the text size. */
   } else if( type == GRF__ESSIZ ) {
      if( value < 0 ) value = 100.0;
      GAttr( this, GRF__SIZE, 0.01*value*nsize, NULL, GRF__TEXT,
             method, class, status );

/* Type GRF__ESWID: Change the text width. */
   } else if( type == GRF__ESWID ) {
      if( value < 0 ) value = 100.0;
      GAttr( this, GRF__WIDTH, 0.01*value*nwidth, NULL, GRF__TEXT,
             method, class, status );

/* Type GRF__ESFON: Change the text font. */
   } else if( type == GRF__ESFON ) {
      if( value < 0 ) value = nfont;
      GAttr( this, GRF__FONT, value, NULL, GRF__TEXT, method, class, status );

/* Type GRF__ESCOL: Change the text colour. */
   } else if( type == GRF__ESCOL ) {
      if( value < 0 ) value = ncol;
      GAttr( this, GRF__COLOUR, value, NULL, GRF__TEXT, method, class, status );

/* Type GRF__ESSTY: Change the text style. */
   } else if( type == GRF__ESSTY ) {
      if( value < 0 ) value = nstyle;
      GAttr( this, GRF__STYLE, value, NULL, GRF__TEXT, method, class, status );

/* Type GRF__ESPSH: Push current attributes onto a stack. */
   } else if( type == GRF__ESPSH ) {
      PushGat( this, *rise, method, class, status );

/* Type GRF__ESSTY: Reset everything to normal. */
   } else if( type == GRF__ESPOP ) {

      if( !PopGat( this, &new_rise, method, class, status ) ) {
         new_rise = 0.0;
         GAttr( this, GRF__SIZE, nsize, NULL, GRF__TEXT, method, class, status );
         GAttr( this, GRF__WIDTH, nwidth, NULL, GRF__TEXT, method, class, status );
         GAttr( this, GRF__COLOUR, ncol, NULL, GRF__TEXT, method, class, status );
         GAttr( this, GRF__FONT, nfont, NULL, GRF__TEXT, method, class, status );
         GAttr( this, GRF__STYLE, nstyle, NULL, GRF__TEXT, method, class, status );
      }

      *x -= 0.01*ux*( *rise - new_rise );
      *y -= 0.01*uy*( *rise - new_rise );
      *rise = new_rise;

   }
}

static int IsASkyAxis( AstFrame *frm, int axis, int *status ) {
/*
*  Name:
*     IsASkyAxis

*  Purpose:
*     Checks if a specified axis of the supplied Frame is a SkyAxis.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int IsASkyAxis( AstFrame *frm, int axis, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function checks if if a specified axis of the supplied Frame is
*     a SkyAxis.

*  Parameters:
*     frm
*        The Frame.
*     axis
*        The zero-based axis index.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A boolean flag indicating if the axis is a  SkyAxis.

*/

/* Local Variables: */
   int ret;
   AstAxis *ax;

/* initialise */
   ret = 0;

/* Check the global status. */
   if( !astOK ) return ret;

/* Extract the required axis from the Frame and test if it is a SkyAxis.
   Then free the axis memory. */
   ax = astGetAxis( frm, axis );
   ret = astIsASkyAxis( ax );
   ax = astAnnul( ax );

/* Return the answer. */
   return ret;

}

static int IsASkyFrame( AstObject *obj, int *status ) {
/*
*  Name:
*     IsASkyFrame

*  Purpose:
*     Checks if the supplied Object ca be treated as a SkyFrame.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int IsASkyFrame( AstObject *obj, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function checks if the supplied Object is a SkyFrame or a
*     FrameSet which has a SkyFrame as its current Frame.

*  Parameters:
*     obj
*        The object.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A boolean flag indicating if the Object can be treated as SkyFrame.

*/

/* Local Variables: */
   int ret;
   AstFrame *frm;

/* initialise */
   ret = 0;

/* Check the global status. */
   if( !astOK ) return ret;

/* If the Object is a SkyFrame, return 1. */
   if( astIsASkyFrame( obj ) ) {
      ret = 1;

/* If the Object is a FrameSet, check its current Frame recursively,
   using this method. */
   } else if( astIsAFrameSet( obj ) ) {
      frm = astGetFrame( (AstFrameSet *) obj, AST__CURRENT );
      ret = IsASkyFrame( (AstObject *) frm, status );
      frm = astAnnul( frm );
   }

/* Return the answer. */
   return ret;

}

static const char *JustMB( AstPlot *this, int esc, const char *text, float *x,
                           float *y, float upx, float upy, const char *just,
                           float uxu, float uyu, float rxu, float ryu,
                           float *x0, float *y0, const char *method,
                           const char *class, int *status ){
/*
*  Name:
*     JustMB

*  Purpose:
*     Modifies a "M" vertical reference point to be a "B" reference point,
*     if necessary.

*  Synopsis:
*     #include "plot.h"
*     const char *JustMB( AstPlot *this, int esc, const char *text, float *x,
*                         float *y, float upx, float upy, const char *just,
*                         float uxu, float uyu, float rxu, float ryu,
*                         float *x0, float *y0, const char *method,
*                         const char *class, int *status )

*  Description:
*     This function is used to modify the reference point and justification
*     of a string by converting the vertical "M" justification option (which
*     indicates that the reference point refers to the bottom of the
*     bounding box) into a corresponding "B" option (which indicates that
*     the reference point refers to the text baseline). The reference
*     point is modified accordingly.
*
*     This is only done if the grf module does not support "M"
*     justification. Otherwise, the supplied justification string and
*     reference point coordinates are returned unchanged.

*  Parameters:
*     this
*        The plot.
*     esc
*        Should escape sequences be interpreted? They will be printed
*        literally otherwise.
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        Pointer to a double holding the x coordinate at the reference
*        point. This is modified on exit if the supplied "just" string
*        indicates that the supplied value refers to the bottom of the
*        bounding box, and the grf module does not support such
*        justification. In this case, the returned value is a point on
*        the baseline of the text which would result in the bottom of
*        the bounding box being at the supplied position.
*     y
*        Pointer to a double holding the y coordinate at the reference
*        point. This is modified on exit if the supplied "just" string
*        indicates that the supplied value refers to the bottom of the
*        bounding box, and the grf module does not support such
*        justification. In this case, the returned value is a point on
*        the baseline of the text which would result in the bottom of
*        the bounding box being at the supplied position.
*     upx
*        The x component of the up-vector for the text. Positive values
*        always refer to displacements from left to right on the screen,
*        even if the graphics x axis increases in the opposite sense.
*     upy
*        The y component of the up-vector for the text. Positive values
*        always refer to displacements from left to right on the screen,
*        even if the graphics y axis increases in the opposite sense.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", 'B' for "baseline" or "M" for "bottom", and
*        specifies the vertical location of the reference position. Note,
*        "baseline" corresponds to the base-line of normal text,and "M"
*        corresponds to the bottom of the bounding box. Some characters
*        (eg "y", "g", "p", etc) and sub-scripts descend below the base-line.
*        The second character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     uxu
*        X component of normalised up-vector, in graphics coords.
*     uyu
*        Y component of normalised up-vector, in graphics coords.
*     rxu
*        X component of normalised right-vector, in graphics coords.
*     ryu
*        Y component of normalised right-vector, in graphics coords.
*     x0
*        Address of a float at which to return the x coordinate at the
*        left end of the baseline of the whole string.
*     y0
*        Address of a float at which to return the y coordinate at the
*        left end of the baseline of the whole string.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a dynamically allocated string which contains the
*     justification to use in future. This pointer should be freed using
*     astFree when no longer needed. This string will contain a full
*     upper-case justification string which can be used by the current
*     grf module.

*  Notes;
*     - NULL is returned if an error has occurred.

*/

/* Local Variables: */
   char cc;
   float drop;
   float dx;
   float dy;
   float f;
   float height;
   float width;
   float xbn[ 4 ];
   float ybn[ 4 ];
   int called;
   char *result;

/* Check inherited status */
   if( !astOK ) return NULL;

/* Allocate memory for the returned string. */
   result = astMalloc( sizeof( char )*3 );
   if( astOK ) {

/* Fill in any missing parts of the justification string. */
      if( just ){
         cc = toupper( just[ 0 ] );
         result[ 0 ] = ( cc == 'T' || cc == 'C' || cc == 'B' || cc == 'M' ) ? cc : 'C';

         cc = toupper( just[ 1 ] );
         result[ 1 ] = ( cc == 'L' || cc == 'C' || cc == 'R' ) ? cc : 'C';

      } else {
         result[ 0 ] = 'C';
         result[ 1 ] = 'C';
      }

      result[ 2 ] = 0;

/* Indicate that DrawText has not been called. */
     called = 0;

/* The justfication need not be changed unless the requested vertical
   justification is "bottom" (m), AND the grf module does not support "M"
   justification. */
      if( ( result[ 0 ] == 'M' ) && !GCap( this, GRF__MJUST, 1, status ) ){

/* Find the bounding box which would result from putting the left end of
   the baseline at the specified position. */
         DrawText( this, 0, esc, text, *x, *y, "BL", upx, upy, xbn, ybn,
                   &drop, method, class, status );

/* Indicate that DrawText has not been called. */
         called = 1;

/* Get the vector from the bottom left corner of the bounding box to the
   reference point (on the base-line), and add this vector on to the reference
   point. */
         *x += *x - xbn[ 0 ];
         *y += *y - ybn[ 0 ];

/* Modified the returned justification string. */
         result[ 0 ] = 'B';
      }

/* If the returned justification is "BL", then the left end of the
   baseline is just the returned reference point. */
      if( result[ 0 ] == 'B' && result[ 1 ] == 'L' ) {
         *x0 = *x;
         *y0 = *y;

/* Otherwise, we work out the coords of the left end of the baseline from
   the values returned by DrawText above. Call DrawText now if it was not
   called above. */
      } else {
         if( ! called ) {
            DrawText( this, 0, esc, text, *x, *y, "BL", upx, upy, xbn, ybn,
                      &drop, method, class, status );
         }

/* Find the height and width of the bounding box. */
         dx = xbn[ 0 ] - xbn[ 3 ];
         dy = ybn[ 0 ] - ybn[ 3 ];
         width = sqrt( dx*dx + dy*dy );

         dx = xbn[ 0 ] - xbn[ 1 ];
         dy = ybn[ 0 ] - ybn[ 1 ];
         height = sqrt( dx*dx + dy*dy );

/* For "C" and "R" horizontal justification we first need to move the
   returned reference point left by 0.5 or 1.0 times the width of the whole
   string respectively. */
         if( result[ 1 ] == 'C' ) {
            f = 0.5;

         } else if( result[ 1 ] == 'R' ) {
            f = 1.0;

         } else {
            f = 0.0;
         }

         f *= width;

         *x0 = *x - f*rxu;
         *y0 = *y - f*ryu;

/* Unless the vertical justification is "B", we also need to move the
   concatenation point vertically to put it on the baseline. */
         if( result[ 0 ] == 'T' ) {
            f = height - drop;

         } else if( result[ 0 ] == 'C' ) {
            f = 0.5*height - drop;

         } else if( result[ 0 ] == 'M' ) {
            f = -drop;

         } else {
            f = 0.0;
         }

         *x0 -= f*uxu;
         *y0 -= f*uyu;
      }
   }

/* Return the result. */
   return result;
}

static int Labelat( AstPlot *this, TickInfo **grid, AstPlotCurveData **cdata,
                    double *labelat, const char *method, const char *class,
                    int *status ){
/*
*
*  Name:
*     Labelat

*  Purpose:
*     Determine the other axis value at which to place interior labels
*     and tick marks.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Labelat( AstPlot *this, TickInfo **grid, AstPlotCurveData **cdata,
*                  double *labelat, const char *method, const char *class )

*  Class Membership:
*     Plot member function.

*  Description:
*     If tick marks and labels are to be placed within the plotting area,
*     the tick values stored in "grid" determine their position on one
*     axis, and their position on the other axis is determined by this
*     function. If a value has been set for the "LabelAt" attribute, then
*     it is used, otherwise the "other axis" value on the longest curve
*     parallel to the "other axis" is used (although the curve "other axis
*     = zero" is used if it passes through the plotting area and is not too
*     short). The effective length assigned to each curve is reduced in
*     proportion to the number of tick marks which are close to the edge
*     of the plotting area.
*
*     A flag is returned indicating if the two axes appear to be
*     independent, in which case there is nothing to be gained by using
*     interior labelling.

*  Parameters:
*     this
*        A pointer to the Plot.
*     grid
*        A pointer to an array of two TickInfo pointers (one for each axis),
*        each pointing to a TickInfo structure holding information about
*        tick values on the axis. See function GridLines.
*     cdata
*        A pointer to an array of two AstPlotCurveData pointers (one for each axis),
*        each pointing to an array of AstPlotCurveData structure (one for each
*        major tick value on the axis), holding information about breaks
*        in the curves drawn to mark the major tick values. See function
*        DrawGrid.
*     labelat
*        A pointer to a 2 element array in which to store the constant axis
*        values at which tick marks are put. Element 0 is returned holding
*        the axis 1 value at which tick marks for axis 0 are placed. Element
*        1 is returned holding the axis 0 value at which tick marks for axis
*        1 are placed.
*     flags
*        A pointer to a 2 element array. Each element is a flag which is
*        returned non-zero if the corresponding axis
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.

*  Returned Value:
*     Zero if and only if the lines of constant axis value are all the
*     same length for all tick marks on either axis. If this is so, using
*     interior labelling will not enable any more major ticks to be
*     drawn, and so there is no reason to switch to interior labelling (unless
*     the user has specifically requested interior labelling).

*  Notes:
*     -  This function assumes the current Frame of the Plot is 2
*     dimensional, and it should not be called if this is not the case.
*/

/* Local Variables: */
   AstMapping *mapping;   /* Mapping from graphics to physical coords */
   AstPointSet *pset2;    /* Pointset for graphical tick positions */
   AstPointSet *pset[ 2 ];/* Pointsets for physical tick positions */
   AstPlotCurveData *cdt; /* Pointer to the AstPlotCurveData for the next tick */
   TickInfo *info;        /* Pointer to the TickInfo for the current axis */
   double **ptr2;         /* Pointers to graphics pointset data */
   double *ptr1[ 2 ];     /* Pointers to physical pointset data */
   double *tvals[ 2 ];    /* Pointers to arrays of other axis values */
   double *value;         /* Current tick value */
   double efflen;         /* Effective length of current curve */
   double lim;            /* Largest insignificant axis value */
   double margin;         /* Width of margin around plotting area */
   double maxlen;         /* Effective length of longest curve */
   double minlen;         /* Effective length of shortest (non-zero) curve */
   double x;              /* Tick X value */
   double xhi;            /* Upper limit on acceptable X range */
   double xlo;            /* Lower limit on acceptable X range */
   double y;              /* Tick Y value */
   double yhi;            /* Upper limit on acceptable Y range */
   double ylo;            /* Lower limit on acceptable Y range */
   double zerolen;        /* Effective length of curve for other axis = 0.0 */
   int axis;              /* Current axis index */
   int i;                 /* Tick index for this axis */
   int nin;               /* No. of counted ticks */
   int result;            /* Does interior labelling allow more ticks to be drawn? */
   int tick;              /* Tick index */

/* Check the global status. */
   if( !astOK ) return 0;

/* Initialise */
   result = 1;

/* Create two PointSets to hold a set of tick mark positions along each
   axis. The values on "axis" will be taken from the info structure. For
   each axis create an array to hold values for the "other" axis. */
   for( axis = 0; axis < 2; axis++ ){
      info = grid[ axis ];
      pset[ axis ] = astPointSet( info->nmajor, 2, "", status );
      tvals[ axis ] = (double *) astMalloc( sizeof(double)*(size_t)(info->nmajor) );
   }

/* Get the mapping from Base (graphics) frame the Current (physical) */
   mapping = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Get the bounds of the area in which tick marks must occur to be
   counted. This is the total plotting area minus a 5% margin at each
   edge. */
   margin = 0.05*( this->xhi - this->xlo );
   xlo = this->xlo + margin;
   xhi = this->xhi - margin;

   margin = 0.05*( this->yhi - this->ylo );
   ylo = this->ylo + margin;
   yhi = this->yhi - margin;

/* Do each axis. */
   for( axis = 0; axis < 2 && astOK; axis++ ){

/* Find the longest and shortest curves parallel to the axis being labelled.
   Also find the length of the curve which passes through the origin of the
   other axis which is within the plotting area. We need to do this even
   if LabelAt has been set since we need to calculate the returned flag. */

/* Store pointers to the arrays holding tick mark physical coordinates,
   and set these in the PointSet. */
      ptr1[ axis ] = grid[ axis ]->ticks;
      ptr1[ 1 - axis ] = tvals[ axis ];
      astSetPoints( pset[ axis ], ptr1 );

/* Get a pointer to the structure containing information describing the
   positions of the major tick marks along the other axis. */
      info = grid[ 1 - axis ];

/* Get a pointer to the other axis value at the first other axis major tick
   mark. */
      value = info->ticks;

/* Get a limit on absolute magnitude for an axis value to be consider
   equal to zero. */
      lim = 1.0E-6*fabs( value[ 1 ] - value [ 0 ] );

/* Get a pointer to the structure containing information describing the
   breaks in the curve which passes through the first major tick mark. */
      cdt = cdata[ 1 - axis ];

/* Initialise the effective length of the longest and shortest curves, and
   the curve passing through the origin. */
      maxlen = -1.0;
      minlen = DBL_MAX;
      zerolen = 0.0;
      labelat[ axis ] = AST__BAD;

/* Loop round each of the major tick marks on the other axis. */
      for( tick = 0; tick < info->nmajor && astOK; tick++ ){

/* Fill the array of other axis values with the current other axis value. */
         for( i = 0; i < grid[ axis ]->nmajor; i++ ){
            tvals[ axis ][ i ] = *value;
         }

/* Transform the tick positions from the current frame (i.e. physical
   coordinates) to the base frame (i.e. graphics coordinates) using
   the inverse Mapping. */
         pset2 = Trans( this, NULL, mapping, pset[ axis ], 0, NULL, 0,
                        method, class, status );

/* Get pointers to the graphics coordinates. */
         ptr2 = astGetPoints( pset2 );
         if( astOK ) {

/* Count the number of graphics positions which are well within the plotting
   area. */
            nin = 0;
            for( i = 0; i < grid[ axis ]->nmajor; i++ ){
               x = ptr2[ 0 ][ i ];
               y = ptr2[ 1 ][ i ];
               if( x != AST__BAD && x > xlo && x < xhi &&
                   y != AST__BAD && y > ylo && y < yhi ) nin++;
            }

/*  Find the effective length of this curve.*/
            efflen = sqrt( (float) nin )*cdt->length;

/* If the curve through this tick mark has a greater effective length than any
   other found so far, record it. */
            if( efflen > maxlen ){
               maxlen = efflen;
               labelat[ axis ] = *value;
            }

/* If the curve through this tick mark has a smaller non-zero effective length
   than any other found so far, record it. */
            if( efflen < minlen && efflen > 0.0 ) minlen = efflen;

/* If this tick mark is at the origin, note the effective length. */
            if( fabs( *value ) <= lim ) zerolen = efflen;

/* Get a pointer to the curve through the next major tick mark. */
            cdt++;

/* Get a pointer to the axis value at the next major tick mark. */
            value++;

         }

/* Free resources. */
         pset2 = astAnnul( pset2 );
      }

/* Use the curve through the origin unless it is significantly shorter
   than the longest curve. */
      if( zerolen > 0.4*maxlen ) labelat[ axis ] = 0.0;

/* Return a flag if the lengths of the shortest and longest curves are nearly
   equal. */
      if( ( maxlen - minlen )/( maxlen + minlen ) < 1.0E-5 ) result = 0;

/* If the LabelAt attribute has been set, use it in preference to the
   value found above. */
      if( astTestLabelAt( this, axis ) ){
         labelat[ axis ] = astGetLabelAt( this, axis );
      }
   }

/* Release resources. */
   for( axis = 0; axis < 2; axis++ ){
      if( pset[ axis ] ) pset[ axis ] = astAnnul( pset[ axis ] );
      if( tvals[ axis ] ) tvals[ axis ] = (double *) astFree( (void *) tvals[ axis ] );
   }
   mapping = astAnnul( mapping );

/* Return. */
   return result;

}

static void Labels( AstPlot *this, TickInfo **grid, AstPlotCurveData **cdata,
                    double *gap, double *labelat, const char *method,
                    const char *class, int *status ){
/*
*
*  Name:
*     Labels

*  Purpose:
*     Draw numerical axis labels for a 2-D annotated coordinate grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Labels( AstPlot *this, TickInfo **grid, AstPlotCurveData **cdata,
*                  double *gap, double *labelat, const char *method,
*                  const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     The policy for placing labels for the major tick values is broadly as
*     follows: if possible, labels for a given physical axis are placed on
*     one edge of the plotting area, at the place where the curve for a
*     major tick value crosses the edge. If very few of the curves cross
*     the edge, then the label for a curve is placed at the intersection
*     of that curve with the longest of the curves representing the major
*     tick values on the other axis.

*  Parameters:
*     this
*        A pointer to the Plot.
*     grid
*        A pointer to an array of two TickInfo pointers (one for each axis),
*        each pointing to a TickInfo structure holding information about
*        tick values on the axis. See function GridLines.
*     cdata
*        A pointer to an array of two AstPlotCurveData pointers (one for each axis),
*        each pointing to an array of AstPlotCurveData structure (one for each
*        major tick value on the axis), holding information about breaks
*        in the curves drawn to mark the major tick values. See function
*        DrawGrid.
*     gap
*        Pointer to array of two values holding the gap between major
*        tick values on the two axes.
*     labelat
*        A pointer to a 2 element array holding the constant axis
*        values at which tick marks are put. Element 0 should hold
*        the axis 1 value at which tick marks for axis 0 are placed. Element
*        1 should hold the axis 0 value at which tick marks for axis
*        1 are placed. If labels are to be placed round the edges of the
*        plotting zone instead of within the plotting zone, then values of
*        AST__BAD should be supplied.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  This function assumes the current Frame of the Plot is 2
*     dimensional, and it should not be called if this is not the case.
*/

/* Local Variables: */
   AstFrame *frame;       /* Pointer to current Frame */
   AstMapping *mapping;   /* Pointer to graphics->physical Mapping */
   AstPointSet *pset1;    /* Pointer to PointSet holding physical coords. */
   AstPointSet *pset2;    /* Pointer to PointSet holding graphics coords. */
   LabelList *labellist;  /* Pointer to list of labels to be plotted */
   LabelList *ll;         /* Pointer to next label to be plotted */
   TickInfo *info;        /* Pointer to the TickInfo for the current axis */
   char just_buf[3];      /* Buffer to hold a justification string */
   const char *just;      /* Justification string */
   const char *text;      /* Pointer to label text */
   double *used;          /* Pointer to list of used label values */
   double *value;         /* Current tick value */
   double diff;           /* Difference between adjacent major tick marks */
   double dx;             /* Text base-line X component */
   double dy;             /* Text base-line Y component */
   double gx;             /* Reference position graphics X coord. */
   double gy;             /* Reference position graphics Y coord. */
   double mindim;         /* Shortest dimension of plotting area */
   double offx;           /* X component of offset vector */
   double offy;           /* Y component of offset vector */
   double rlen;           /* Length of perpendicular vector */
   double rx;             /* X comp of vector perpendicular to (dx,dy) */
   double ry;             /* Y comp of vector perpendicular to (dx,dy) */
   double sin45;          /* Sine of 45 degrees */
   double txtgap;         /* Absolute gap between labels and edges */
   double upx;            /* Text up-vector X component */
   double upy;            /* Text up-vector Y component */
   double val[ 2 ];       /* Physical coordinates */
   float *box;            /* Pointer to array of label bounding boxes */
   float alpha;           /* Factor to convert graphics X to equal scaled X */
   float beta;            /* Factor to convert graphics Y to equal scaled Y */
   int axis;              /* Current axis index */
   int esc;               /* Interpret escape sequences? */
   int flag;              /* Flag indicating which way the base-vector points */
   int iused;             /* Index into list of used axis values */
   int logticks;          /* ARe major ticks spaced logarithmically? */
   int nlab;              /* The number of labels to be plotted */
   int nused;             /* Number of used axis values */
   int t0;                /* Index of central tick */
   int tick;              /* Current tick index */
   int tinc;              /* Increment between ticks */
   int upfree;            /* Are we free to change the up-vector? */
   int gelid;             /* ID for next graphical element to be drawn */

/* Check the global status. */
   if( !astOK ) return;

/* See if escape sequences in text strings are to be interpreted */
   esc = astGetEscape( this );

/* Empty the list of bounding boxes kept by the Overlap function. */
   (void) Overlap( this, 0, 0, NULL, 0.0, 0.0, NULL, 0.0, 0.0, NULL,
                   method, class, status );

/* If required, draw the labels around the edges of the plotting area. */
   if( labelat[ 0 ] == AST__BAD || labelat[ 1 ] == AST__BAD ){
      (void) EdgeLabels( this, 1, grid, cdata, 1, method, class, status );

/* Otherwise, draw labels within the interior of the plotting area. */
   } else {

/* Find the scale factors for the two axes which scale graphics coordinates
   into a "standard" equal scaled coordinate system in which: 1) the axes
   have equal scale in terms of (for instance) millimetres per unit distance,
   2) X values increase from left to right, 3) Y values increase from bottom
   to top. */
      GScales( this, &alpha, &beta, method, class, status );

/* Get the minimum dimension of the plotting area in equal scaled coords. */
      mindim = astMIN( fabs( alpha*(this->xhi - this->xlo) ),
                    fabs( beta*(this->yhi - this->ylo) ) );

/* Store a value for the sine of 45 degrees. */
      sin45 = 1.0/sqrt( 2.0 );

/* Initialise the pointer to the memory holding the bounding boxes for
   all labels (used by function Overlap). */
      box = NULL;

/* Get a pointer to the current Frame in the Plot. */
      frame = astGetFrame( this, AST__CURRENT );

/* Get a pointer to the mapping form the base Frame to the current Frame in
   the Plot. */
      mapping = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Initialize the id value for graphical element being drawn. */
      gelid = AST__NUMLAB1_ID;

/* Do each axis. */
      for( axis = 0; axis < 2; axis++ ){

/* See of major ticks are spaced logarithmically on this axis. */
         logticks = astGetLogTicks( this, axis );

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
         astGrfAttrs( this, gelid, 1, GRF__TEXT, method, class );

/* Get a pointer to the structure containing information describing the
   positions of the major tick marks along this axis. */
         info = grid[ axis ];

/* Only progress if there are some labels stored within the structure. */
         if( info->labels ) {

/* Initialise the pointer to the list of text strings to be drawn. */
            labellist = NULL;
            nlab = 0;

/* See if numerical labels are always to be drawn horizontal. If so, set
   a flag and initialise a vertical up-vector. */
            if( astGetLabelUp( this, axis ) ){
               upfree = 0;
               upx = 0.0;
               upy = 1.0;

/* Otherwise, clear the flag and indicate that we do not yet have an
   up-vector. */
            } else {
               upfree = 1;
               upx = AST__BAD;
               upy = AST__BAD;
            }

/* Indicate that the tangent vector to the other axis is not yet
   known. */
            dx = AST__BAD;
            dy = AST__BAD;
            gx = AST__BAD;
            gy = AST__BAD;

/* Store the gap to put next to the label text. This is in equal scaled
   coords, not graphics coords. */
            txtgap = astGetNumLabGap( this, axis )*mindim;

/* Get a pointer to the axis value at the first major tick mark. */
            value = info->ticks;

/* Initialise pointers to two PointSets which will be created and used
   within function GVec. */
            pset1 = NULL;
            pset2 = NULL;

/* Get memory to hold the axis values at which labels have been put. */
            used = (double *) astMalloc( sizeof(double)*(size_t)info->nmajor );
            nused = 0;

/* The tick marks are done in two batches, each batch working out from the
   middle. This is done because there may be extra tick marks outside the
   normal ranges at the extremes, and these should not be given the
   priority caused by doing them first. Store the mid-tick index, the
   current tick index, and the increment between ticks. The ticks from the
   middle up to the highest index are done first. */
            t0 = info->nmajor/2;
            tick = t0 - 1;
            tinc = 1;

/* Loop round until all ticks have been done. */
            while( (tick += tinc) >= 0 && astOK ){

/* If we have done the highest tick index, start again at the tick just
   below middle, and work done towards index zero. */
               if( tick == info->nmajor ){
                  tick = t0 - 1;
                  tinc = -1;
               }

/* Store the reference position for the label . */
               val[ axis ] = value[ tick ];
               val[ 1 - axis ] = labelat[ axis ];

/* Store the difference between this tick and the next. */
               if( logticks ) {
                  diff = value[ tick ]*( gap[ axis ] - 1.0 );
               } else {
                  diff = gap[ axis ];
               }

/* See if this axis value has already been used. */
               for( iused = 0; iused < nused; iused++ ){
                  if( fabs( val[ axis ] - used[ iused ] ) <
                      1.0E-3*diff ) break;
               }

/* If the axis value has already been used, don't use it again. */
               if( iused >= nused || nused == 0 ){
                  used[ nused++ ] = val[ axis ];

/* We now need to decide where to put the reference point for the text
   string, and what justification to use. Assuming that NumLabGap is +ve,
   the labels are drawn on the left hand side of the axis as seen by
   someone moving along the axis in the positive direction, with an
   up-vector which is normal to the axis tangent. First, find the graphics
   coordinates at the point being labelled, and the unit tangent-vector
   parallel to the axis being labelled. If the tangent vector is not defined,
   then the tangent vector used for the previous label is re-used. This
   unit tangent vector is expressed in graphics coords. */
                  GVec( this, mapping, val, axis, 0.01*diff, &pset1,
                        &pset2, &gx, &gy, &dx, &dy, &flag, method, class,
                        status );

/* If we now have a tangent vector and good graphics coordinates for the
   label's reference position... */
                  if( dx != AST__BAD && dy != AST__BAD &&
                      gx != AST__BAD && gy != AST__BAD ){

/* Convert the unit tangent vector from graphics coords to equal-scaled coords. */
                     dx *= alpha;
                     dy *= beta;

/* Rotate through 90 degrees to get a vector perpendicular to the axis in
   equal scaled coords. This vector points to the left as you move along
   the physical axis in the positive direction. Find its length. */
                     rx = -dy;
                     ry = dx;
                     rlen = sqrt( rx*rx + ry*ry );

/* The reference position for the text is displaced away from the
   reference position normal to the axis on the left hand side by the
   "txtgap" value. */
                     offx = rx*txtgap/rlen;
                     offy = ry*txtgap/rlen;
                     gx += offx/alpha;
                     gy += offy/beta;

/* The up-vector and justification for the text depends on whether or
   not the up-vector is free to rotate. If it is free, the up-vector is
   chosen so that the text is not upside-down. Note, the up-vector is
   specified in the equally scaled coordinate system. */
                     if( upfree ){

                        if( dx < -0.01*fabs( alpha ) ){
                           upx = -rx;
                           upy = -ry;
                           just = ( txtgap < 0.0 )? "BC" : "TC";
                        } else {
                           upx = rx;
                           upy = ry;
                           just = ( txtgap < 0.0 )? "TC" : "BC";
                        }
                        if( txtgap == 0.0 ) just = "CC";

/* If the up vector is required to be vertical, a system is used which
   tries to put the centre of the text string on or near the offset
   vector. */
                     } else {
                        upx = 0.0;
                        upy = 1.0;

                        if( offy > fabs(txtgap)*sin45 ){
                           just_buf[0] = 'B';
                        } else if( offy < -fabs(txtgap)*sin45 ){
                           just_buf[0] = 'T';
                        } else {
                           just_buf[0] = 'C';
                        }
                        if( txtgap == 0.0 ) just_buf[0] = 'C';

                        if( offx < -fabs(txtgap)*sin45 ){
                           just_buf[1] = 'R';
                        } else if( offx > fabs(txtgap)*sin45 ){
                           just_buf[1] = 'L';
                        } else {
                           just_buf[1] = 'C';
                        }
                        if( txtgap == 0.0 ) just_buf[1] = 'C';

                        just_buf[2] = 0;
                        just = just_buf;
                     }

/* Get the label text. */
                     text = (info->labels)[ tick ];
                     if( text ){

/* Check that the reference position is within the plotting area.
   If so, add it to the list of labels to be drawn. */
                        if( gx >= this->xlo && gx <= this->xhi &&
                            gy >= this->ylo && gy <= this->yhi ){

                           labellist = (LabelList *) astGrow( (void *) labellist, nlab + 1, sizeof(LabelList) );
                           if ( astOK ) {
                              (labellist + nlab)->index = tick;
                              (labellist + nlab)->text = (char *) astStore( NULL, (void *) text, strlen(text) + 1 );
                              (labellist + nlab)->x = gx;
                              (labellist + nlab)->y = gy;
                              (labellist + nlab)->just = (char *) astStore( NULL, (void *) just, strlen(just) + 1 );
                              (labellist + nlab)->upx = upx;
                              (labellist + nlab)->upy = upy;
                              (labellist + nlab)->val = val[ axis ];
                              nlab++;
                           } else {
                              break;
                           }
                        }
                     }
                  }
               }
            }

/* If any labels were stored, draw the text strings, and then release the
   memory used to hold the text, etc. */
            if( nlab > 0 ) {
               PlotLabels( this, esc, frame, axis, labellist, info->fmt, nlab,
                           &box, method, class, status );
               ll = labellist;
               for( tick = 0; tick < nlab; tick ++ ) {
                  ll->text = (char *) astFree( (void *) ll->text );
                  ll->just = (char *) astFree( (void *) ll->just );
                  ll++;
               }
               labellist = (LabelList *) astFree( (void *) labellist );
            }

/* Free the memory used to hold the axis values at which labels have
   been put. */
            used = (double *) astFree( (void *) used );

/* Annul the PointSets (if used). */
            if( pset1 ) pset1 = astAnnul( pset1 );
            if( pset2 ) pset2 = astAnnul( pset2 );

/* Re-establish the original graphical attributes. */
            astGrfAttrs( this, gelid, 0, GRF__TEXT, method, class );

/* Set up the id for the next graphical element to be drawn. */
            gelid = AST__NUMLAB2_ID;

         }
      }

/* Free the memory used to hold the bounding boxes. */
      box = (float *) astFree( (void *) box );

/* Annul the pointers to the Frame and the Mapping. */
      mapping = astAnnul( mapping );
      frame = astAnnul( frame );

   }

/* Return. */
   return;

}

static void LinePlot( AstPlot *this, double xa, double ya, double xb,
                      double yb, int ink, AstPlotCurveData *cdata,
                      const char *method, const char *class, int *status ){
/*
*
*  Name:
*     LinePlot

*  Purpose:
*     Draws a straight line omitting bad regions.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void LinePlot( AstPlot *this, double xa, double ya, double xb,
*                    double yb, int ink, AstPlotCurveData *cdata,
*                    const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws a straight line between two positions in graphics
*     coordinates but leaves gaps in the line where it passes through
*     regions which have no corresponding physical coordinates.

*  Parameters:
*     this
*        Pointer to the Plot.
*     xa
*        The graphics X coordinate at the start of the line.
*     ya
*        The graphics Y coordinate at the start of the line.
*     xb
*        The graphics X coordinate at the end of the line.
*     yb
*        The graphics Y coordinate at the end of the line.
*     ink
*        If zero, the line is not actually drawn, but information about
*        the breaks is still returned. If non-zero, the line is also drawn.
*     cdata
*        A pointer to a structure in which to return information about the
*        breaks in the line.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  No curve is draw if any of the start or end positions are bad
*     (i.e. equal to AST__BAD), or if a NULL pointer is supplied for "cdata".
*     No errors are reported in these cases.
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   double d[ CRV_NPNT ];   /* Offsets to evenly spaced points along curve */
   double x[ CRV_NPNT ];   /* X coords at evenly spaced points along curve */
   double y[ CRV_NPNT ];   /* Y coords at evenly spaced points along curve */
   double tol;             /* Absolute tolerance value */
   int i;                  /* Loop count */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Check the supplied values are usable. */
   if( xa == AST__BAD || ya == AST__BAD ||
       xb == AST__BAD || yb == AST__BAD ||
      !cdata ) return;

/* Convert the tolerance from relative to absolute graphics coordinates. */
   tol = astGetTol( this )*astMAX( this->xhi - this->xlo, this->yhi - this->ylo );

/* Ensure the globals holding the scaling from graphics coords to equally
   scaled coords are available. */
   GScales( this, NULL, NULL, method, class, status );

/* Set up the external variables used by the Crv and CrvLine function (see
   their prologues for details). */
   Crv_scerr = ( astGetLogPlot( this, 0 ) ||
                 astGetLogPlot( this, 1 ) ) ? 100.0 : 1.5;
   Crv_ux0 = AST__BAD;
   Crv_limit = 0.5*tol*tol;
   Crv_tol = tol;
   Crv_map = Map2;
   Crv_ink = ink;
   Crv_len = 0.0F;
   Crv_xlo = this->xlo;
   Crv_xhi = this->xhi;
   Crv_ylo = this->ylo;
   Crv_yhi = this->yhi;
   Crv_out = 1;
   Crv_xbrk = cdata->xbrk;
   Crv_ybrk = cdata->ybrk;
   Crv_vxbrk = cdata->vxbrk;
   Crv_vybrk = cdata->vybrk;
   Crv_clip = astGetClip( this ) & 1;

/* Create a set of evenly spaced values between 0.0 and 1.0. These are the
   offsets the edge of the plotting zone at which the mapping is tested. */
   for( i = 0; i < CRV_NPNT; i++ ){
     d[ i ] = ( (double) i)/( (double) CRV_NSEG );
   }

/* Now set up the externals used to communicate with the Map2 function.
   Map2 transforms a set of offsets between zero and one into a set of
   corresponding graphics coordinates, with bad values substituted for any
   offsets which correspond to points outside the domain of the mapping. */

/* The number of axes in the physical coordinate system (i.e. the current
   Frame). */
   Map2_ncoord = astGetNout( this );

/* A pointer to the mapping from graphics world cordinates to physical
   coordinates. */
   Map2_plot = this;
   Map2_map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* The graphics coordinates corresponding to an offset of zero (i.e.
   the start of the line). */
   Map2_x0 = xa;
   Map2_y0 = ya;

/* The increments in X and Y between offset zero (the start of the
   line) and offset 1 (the end of the line). */
   Map2_deltax = xb - xa;
   Map2_deltay = yb - ya;

/* Get the graphics coordinates corresponding to the initial set of
   offsets. */
   Map2( CRV_NPNT, d, x, y, method, class, status GLOBALS_NAME );

/* Use Crv and Map2 to draw the intersection of the straight line with
   the region containing valid physical coordinates. */
   Crv( this, d, x, y, 0, NULL, NULL, method, class, status );

/* End the current poly line. */
   Opoly( this, status );

/* Tidy up the static data used by Map2. */
   Map2( 0, NULL, NULL, NULL, method, class, status GLOBALS_NAME );

/* If no part of the curve could be drawn, set the number of breaks and the
   length of the drawn curve to zero. */
   if( Crv_out ) {
      Crv_nbrk = 0;
      Crv_len = 0.0F;

/* Otherwise, add an extra break to the returned structure at the position of
   the last point to be plotted. */
   } else {
      Crv_nbrk++;
      if( Crv_nbrk > AST__PLOT_CRV_MXBRK ){
         astError( AST__CVBRK, "%s(%s): Number of breaks in curve "
                   "exceeds %d.", status, method, class, AST__PLOT_CRV_MXBRK );
      } else {
         *(Crv_xbrk++) = (float) Crv_xl;
         *(Crv_ybrk++) = (float) Crv_yl;
         *(Crv_vxbrk++) = (float) -Crv_vxl;
         *(Crv_vybrk++) = (float) -Crv_vyl;
      }
   }

/* Store extra information about the curve in the returned structure, and
   purge any zero length sections. */
   if( cdata ){
      cdata->length = Crv_len;
      cdata->out = Crv_out;
      cdata->nbrk = Crv_nbrk;
      PurgeCdata( cdata, status );
   }

/* Annul the Mapping. */
   Map2_map = astAnnul( Map2_map );

/* Return. */
   return;

}

static double **MakeGrid( AstPlot *this, AstFrame *frm, AstMapping *map,
                          int disk, int dim, double xlo, double xhi,
                          double ylo, double yhi, int nphy, AstPointSet **pset1,
                          AstPointSet **pset2, int norm, const char *method,
                          const char *class, int *status ){
/*
*  Name:
*     MakeGrid

*  Purpose:
*     Create a square grid of graphics coordinates and the corresponding
*     physical coordinates.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     double **MakeGrid( AstPlot *this, AstFrame *frm, AstMapping *map,
*                        int disk, int dim, double xlo, double xhi, double ylo,
*                        double yhi, int nphy, AstPointSet **pset1,
*                        AstPointSet **pset2, int norm, const char *method,
*                        const char *class, int *status ){

*  Class Membership:
*     Plot member function.

*  Description:
*     This function creates two PointSets, one holding a square grid of
*     graphics coordinates covering the supplied area, and the other
*     holding the corresponding physical coordinates. The points are
*     stored row by row in the returned PointSets, i.e. if the cell size
*     for the grid is (dx,dy), the first point is (xmin,ymin), followed
*     by (xmin+dx,ymin), (xmin+2*dx,ymin), up to (xmin+(dim-1)*dx,ymin),
*     followed by the next row (xmin,ymin+dy), (xmin+dx,ymin+dy), etc.

*  Parameters:
*     this
*        The Plot.
*     frm
*        A pointer to the Current Frame in the Plot. If this is supplied
*        NULL, then a pointer is found within this function if required (i.e.
*        if "norm" is non-zero).
*     map
*        The Mapping from graphics to physical coordinates, extracted from
*        the Plot.
*     disk
*        If non-zero, the corners of the grid are omitted form the
*        returned PointSets, resulting in a grid that is more disk like than
*        rectangular.
*     dim
*        The number of samples along each edge of the grid.
*     xlo
*        The lower bound on the first axis of the region to be covered
*        by the grid.
*     xhi
*        The upper bound on the first axis of the region to be covered
*        by the grid.
*     ylo
*        The lower bound on the second axis of the region to be covered
*        by the grid.
*     yhi
*        The upper bound on the second axis of the region to be covered
*        by the grid.
*     nphy
*        The number of axes in the physical cooridinate system.
*     pset1
*        A pointer to a location at which to store a pointer to the
*        PointSet holding the graphics coordinates.
*     pset2
*        A pointer to a location at which to store a pointer to the
*        PointSet holding the physical coordinates.
*     norm
*        If non-zero the physical cooridnates are normalised using the
*        Plot's astNorm method.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to the physical coordinate data stored in the PointSet
*     "pset2".

*  Notes:
*     - The returned PointSets should be annulled when no longer needed,
*     using astAnnul.
*     -  NULL pointers are returned if an error has already occurred, or
*     if this function should fail for any reason.
*/

/* Local Variables: */
   double **ptr1;    /* Pointers to graphics axis values */
   double **ptr2;    /* Pointers to physical axis values */
   int size;         /* No. of points in the grid */

/* Initialise the returned pointers. */
   *pset1 = NULL;
   *pset2 = NULL;

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* Create two PointSets. We assume for the moment that they cover the
   full grid, including corners. */
   size = dim*dim;
   *pset1 = astPointSet( size, 2, "", status );
   *pset2 = astPointSet( size, nphy, "", status );

/* Get pointers to the data arrays for the two PointSets. */
   ptr1 = astGetPoints( *pset1 );
   ptr2 = astGetPoints( *pset2 );

/* Create a grid covering the supplied area. */
   size = GraphGrid( dim, disk, xlo, xhi, ylo, yhi, ptr1, status );

/* If the corners are being omitted, reduce the number of points in the
   two PointSets. */
   if( disk ) {
      astSetNpoint( *pset1, size );
      astSetNpoint( *pset2, size );
   }

/* Transform these graphics positions to physical coordinates. */
   Trans( this, frm, map, *pset1, 1, *pset2, norm, method, class, status );

/* If an error has occurred, annul the two pointsets. */
   if( !astOK ){
      *pset1 = astAnnul( *pset1 );
      *pset2 = astAnnul( *pset2 );
      ptr2 = NULL;
   }

/* Return. */
   return ptr2;

}


#if defined(THREAD_SAFE)
static int ManageLock( AstObject *this_object, int mode, int extra,
                       AstObject **fail, int *status ) {
/*
*  Name:
*     ManageLock

*  Purpose:
*     Manage the thread lock on an Object.

*  Type:
*     Private function.

*  Synopsis:
*     #include "object.h"
*     AstObject *ManageLock( AstObject *this, int mode, int extra,
*                            AstObject **fail, int *status )

*  Class Membership:
*     Plot member function (over-rides the astManageLock protected
*     method inherited from the parent class).

*  Description:
*     This function manages the thread lock on the supplied Object. The
*     lock can be locked, unlocked or checked by this function as
*     deteremined by parameter "mode". See astLock for details of the way
*     these locks are used.

*  Parameters:
*     this
*        Pointer to the Object.
*     mode
*        An integer flag indicating what the function should do:
*
*        AST__LOCK: Lock the Object for exclusive use by the calling
*        thread. The "extra" value indicates what should be done if the
*        Object is already locked (wait or report an error - see astLock).
*
*        AST__UNLOCK: Unlock the Object for use by other threads.
*
*        AST__CHECKLOCK: Check that the object is locked for use by the
*        calling thread (report an error if not).
*     extra
*        Extra mode-specific information.
*     fail
*        If a non-zero function value is returned, a pointer to the
*        Object that caused the failure is returned at "*fail". This may
*        be "this" or it may be an Object contained within "this". Note,
*        the Object's reference count is not incremented, and so the
*        returned pointer should not be annulled. A NULL pointer is
*        returned if this function returns a value of zero.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*    A local status value:
*        0 - Success
*        1 - Could not lock or unlock the object because it was already
*            locked by another thread.
*        2 - Failed to lock a POSIX mutex
*        3 - Failed to unlock a POSIX mutex
*        4 - Bad "mode" value supplied.

*  Notes:
*     - This function attempts to execute even if an error has already
*     occurred.
*/

/* Local Variables: */
   AstPlot *this;    /* Pointer to Plot structure */
   int result;       /* Returned status value */

/* Initialise */
   result = 0;

/* Check the supplied pointer is not NULL. */
   if( !this_object ) return result;

/* Obtain a pointers to the Plot structure. */
   this = (AstPlot *) this_object;

/* Invoke the ManageLock method inherited from the parent class. */
   if( !result ) result = (*parent_managelock)( this_object, mode, extra,
                                                fail, status );

/* If defined, ensure the grfcontext KeyMap contained within the Plot is
   locked, unlocked or checked. */
   if( this->grfcontext ) {
      if( !result ) result = astManageLock( this->grfcontext, mode, extra, fail );

/* Also lock or unlock the associated object handle. */
      if( mode == AST__LOCK ) {
         if( !result ) astLock( this->grfcontextID, extra );

      } else if( mode == AST__UNLOCK ) {
         if( !result ) astUnlock( this->grfcontextID, 0 );

      }
   }

   return result;

}
#endif

static void Map1( int n, double *dist, double *x, double *y,
                  const char *method, const char *class,
                  int *status GLOBALS_ARG ){
/*
*  Name:
*     Map1

*  Purpose:
*     Find graphics coordinates at given distances along a curve
*     parallel to a physical axis.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Map1( int n, double *dist, double *x, double *y,
*                const char *method, const char *class,
*                int *status [,AstGlobals *AST__GLOBALS] )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied distances are converted into physical coordinates
*     using the scalings described by various external variables, and then
*     these physical coordinates are mapped into graphics coordinates.

*  Parameters:
*     n
*        The number of points to map. Static resources are released but
*        no points are mapped if zero is supplied.
*     dist
*        A pointer to an array holding "n" distances. A "dist" value of
*        zero corresponds to the starting position supplied in external
*        variable Map1_origin. A "dist" value of one corresponds to the
*        finishing position which is a distance Map1_length away from
*        Map1_origin, moving in the positive direction of the axis given
*        by Map1_axis. "dist" values can be either linearly or
*        logarithmically related to axis values (see Map1_log).
*     x
*        A pointer to an array in which to store the "n" graphics X
*        coordinate values corresponding to the positions in "dist".
*     y
*        A pointer to an array in which to store the "n" graphics Y
*        coordinate values corresponding to the positions in "dist".
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.
*     AST__GLOBALS
*        Only present if compiled with -DTHREAD_SAFE. It is a pointer to
*        the structure holding the global data for the executing thread.
*        It is passed as a function parameter, rather than being accessed
*        within this function using the astGET_GLOBALS(NULL) macro (as
*        other Object-less functions do) in order to avoid the time
*        overheads of calling astGET_GLOBALS(NULL) . This function is
*        time-critical.

*  External Variables:
*     Map1_log = int (Read)
*        If zero, then "dist" in learly related to axis value. Otherwise
*        it is linearly related to log10(axis value).
*     Map1_ncoord = int (Read)
*        The number of axes in the physical coordinate system.
*     Map1_axis = int (Read)
*        The zero-based index of the axis which the curve follows (i.e.
*        the axis which changes value along the curve).
*     Map1_statics = Map1Statics * (Read and Write)
*        Pointer to a structure holding other static data used by Map1.
*     Map1_origin = const double * (Read)
*        A pointer to an array holding the physical coordinate value on
*        each axis at the start of the curve (i.e. at dist = 0.0).
*     Map1_length = double (Read)
*        The scale factor to convert "dist" values into increments
*        along the physical axis given by Map1_axis.
*     Map1_plot = AstPlot * (Read)
*        A pointer to the Plot defining the mapping from graphics cordinates
*        to physical coordinates.
*     Map1_map = AstMapping * (Read)
*        A pointer to the mapping from graphics cordinates to physical
*        coordinates extracted from the Plot.
*     Map1_frame = AstFrame * (Read)
*        A pointer to the Current Frame in the Plot.
*     Map1_norm = int (Read)
*        A flag indicating if physical coordinate values which are not in
*        the normal ranges of the corresponding axes should be considered
*        bad.

*  Notes:
*     -  On the first call, this function allocates static resources which
*     are used by subsequent invocation. These resources should be freed before
*     calling this function with new values for any of the external variables,
*     or when no longer needed, by calling this function with "n" supplied as
*     zero.
*     -  If an error has already occurred, this runction returns without
*     action ,except that if "n" is supplied as zero then static resources
*     are released even if an error has already occurred.

*/

/* Local Constants: */
   Map1Statics *statics;     /* Pointer to structure holding static data */
   double *p;                /* Pointer to next value */
   double axval;             /* Axis origin value */
   int i, j;                 /* Loop counts */

/* Convert the global "void *" pointer to a Map1Statics pointer */
   statics = (Map1Statics *) Map1_statics;

/* If zero points were supplied, release static resources and return. */
   if( n == 0 ){
      if( statics ) {
         if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
         if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
         if( statics->work1 ) statics->work1 = (double *) astFree( (void *) statics->work1 );
         if( statics->work2 ) statics->work2 = (double *) astFree( (void *) statics->work2 );
         Map1_statics = astFree( statics );
      }
      return;
   }

/* Otherwise, check the inherited global status. */
   if( !astOK ) return;

/* Create and initialise a structure to hold extra static information if
   this has not already been done. */
   if( !statics ) {
      statics = astMalloc( sizeof( Map1Statics ) );
      if( statics ) {
         statics->pset1 = NULL;
         statics->pset2 = NULL;
         statics->ptr1 = NULL;
         statics->pax = NULL;
         statics->ptr2[ 0 ] = NULL;
         statics->ptr2[ 1 ] = NULL;
         statics->work1 = NULL;
         statics->work2 = NULL;
         statics->nl = 0;
         Map1_statics = statics;
      }
   }

/* If the number of points to be mapped is different to last time,
   set up some PointSets to store the specified number of points. */
   if( n != statics->nl ){
      statics->nl = n;

/* Create a PointSet to hold the physical coordinates corresponding to
   the supplied offsets. First annul any existing PointSet. */
      if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
      statics->pset1 = astPointSet( n, Map1_ncoord, "", status );
      statics->ptr1 = astGetPoints( statics->pset1 );

/* Create a PointSet to hold the corresponding graphics coordinates.
   The supplied "x" and "y" arrays will be used to store the data
   so we do not need to get pointers to the data using astGetPoints. First
   annul any existing PointSet. */
      if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
      statics->pset2 = astPointSet( n, 2, "", status );

/* Get work space to hold two positions. */
      statics->work1 = (double *) astRealloc( (void *) statics->work1,
                                          sizeof(double)*(size_t)Map1_ncoord );
      statics->work2 = (double *) astRealloc( (void *) statics->work2,
                                          sizeof(double)*(size_t)Map1_ncoord );

/* Check the pointer can be used. */
      if( astOK ){

/* Store a pointer to the start of the memory which will be used to store
   the physical data for the axis being drawn. */
         statics->pax = statics->ptr1[ Map1_axis ];

/* Fill the PointSet which is used to hold physical data with the physical
   coordinates at the start of the curve. */
         for( i = 0; i < Map1_ncoord; i++ ){
            axval = Map1_origin[ i ];
            p = statics->ptr1[ i ];
            for( j = 0; j < n; j++ ) *(p++) = axval;
         }

/* Store the scale and offset to apply to the "dist" values. If Map1_log is
   zero (linear axes) then applying these values gives axis value directly.
   If Map1_log is non-zero (log axes) then applying these values gives
   log10( axis value). */
         if( Map1_log ) {
            statics->neg = ( Map1_origin[ Map1_axis ] < 0 );
            statics->axorig = log10( fabs( Map1_origin[ Map1_axis ] ) );
            statics->axscale = log10( fabs( Map1_origin[ Map1_axis ] +
                                   Map1_length ) ) - statics->axorig;
         } else {
            statics->axorig = Map1_origin[ Map1_axis ];
            statics->axscale = Map1_length;
         }
       }
    }

/* Check the initialisation went OK (if done). */
   if( astOK ){

/* Loop round each offset along the curve, converting the normalised offset
   in the range [0,1] to a physical coordinate and storing in PointSet 1. */
      p = statics->pax;
      for( i = 0; i < n; i++){
         *(p++) = statics->axorig + statics->axscale*dist[ i ];
      }
      if( Map1_log ) {
         p = statics->pax;
         for( i = 0; i < n; i++,p++ ){
            *p = statics->neg ? -pow( 10.0, *p ) : pow( 10.0, *p );
         }
      }

/* Store pointers to the results arrays in PointSet 2. */
      statics->ptr2[ 0 ] = x;
      statics->ptr2[ 1 ] = y;
      astSetPoints( statics->pset2, statics->ptr2 );

/* Map all the positions into graphics coordinates. */
      (void) Trans( Map1_plot, NULL, Map1_map, statics->pset1, 0, statics->pset2, 1, method, class, status );

/* If points not in their normal ranges are to be set bad... */
      if( Map1_norm ) {

/* The following code simply normalizes the physical position, and if this
   produces any change, the graphics positions are set bad. */
         for( i = 0; i < n; i++){
            for( j = 0; j < Map1_ncoord; j++) statics->work1[j] = statics->ptr1[j][i];
            astNorm( Map1_frame, statics->work1 );
            for( j = 0; j < Map1_ncoord; j++) {
               if( !astEQUALS( statics->work1[j], statics->ptr1[j][i], 1.0E8 ) ) {
                  statics->ptr2[0][i] = AST__BAD;
                  statics->ptr2[1][i] = AST__BAD;
                  break;
               }
            }
         }
      }
   }

/* Return. */
   return;

}

static void Map2( int n, double *dist, double *x, double *y,
                  const char *method, const char *class,
                  int *status GLOBALS_ARG ){
/*
*  Name:
*     Map2

*  Purpose:
*     Find which graphics coordinates have good physical coordinates
*     at given distances along a straight line.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Map2( int n, double *dist, double *x, double *y,
*                const char *method, const char *class,
*                int *status [,AstGlobals *AST__GLOBALS] )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied distances refer to the distance along a straight line
*     in the graphics coordinate system. The returned graphics coordinates
*     correspond to the supplied distances, except that any position for
*     which there are no defined physical coordinates is returned bad.

*  Parameters:
*     n
*        The number of points to map. Static resources are released but
*        no points are mapped if zero is supplied.
*     dist
*        A pointer to an array holding "n" distances. A "dist" value of
*        zero corresponds to the graphics position supplied in external
*        variables (Map2_x0, Map2_y0). A "dist" value of one corresponds to
*        the graphics position which is offset from the start by the vector
*        (Map2_deltax, Map2_deltay).
*     x
*        A pointer to an array in which to store the "n" graphics X
*        coordinate values corresponding to the positions in "dist",
*        except that any which have no corresponding physical coordinates
*        are set to AST__BAD.
*     y
*        A pointer to an array in which to store the "n" graphics Y
*        coordinate values corresponding to the positions in "dist",
*        except that any which have no corresponding physical coordinates
*        are set to AST__BAD.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.
*     AST__GLOBALS
*        Only present if compiled with -DTHREAD_SAFE. It is a pointer to
*        the structure holding the global data for the executing thread.
*        It is passed as a function parameter, rather than being accessed
*        within this function using the astGET_GLOBALS(NULL) macro (as
*        other Object-less functions do) in order to avoid the time
*        overheads of calling astGET_GLOBALS(NULL) . This function is
*        time-critical.

*  External Variables:
*     Map2_ncoord = int (Read)
*        The number of axes in the physical coordinate system.
*     Map2_x0 = double (Read)
*        The graphics X coordinate at the start of the line (i.e. at dist
*        = 0.0).
*     Map2_y0 = double (Read)
*        The graphics Y coordinate at the start of the line (i.e. at dist
*        = 0.0).
*     Map2_deltax = double (Read)
*        The increment along the graphics X axis between the start and
*        end of the line.
*     Map2_deltay = double (Read)
*        The increment along the graphics Y axis between the start and
*        end of the line.
*     Map2_plot = AstPlot * (Read)
*        A pointer to the Plot defining the mapping from graphics cordinates
*        to physical coordinates.
*     Map2_map = AstMapping * (Read)
*        A pointer to the mapping from graphics cordinates to physical
*        coordinates, extracted from the Plot.
*     Map2_statics = Map2Statics * (Read and Write)
*        Pointer to a structure holding other static data used by Map2.

*  Notes:
*     -  On the first call, this function allocates static resources which
*     are used by subsequent invocation. These resources should be freed before
*     calling this function with new values for any of the external variables,
*     or when no longer needed, by calling this function with "n" supplied as
*     zero.
*     -  If an error has already occurred, this runction returns without
*     action ,except that if "n" is supplied as zero then static resources
*     are released even if an error has already occurred.

*/
/* Local Constants: */
   Map2Statics *statics;           /* Pointer to structure holding static data */
   int i, j;                       /* Loop counts */
   double *p;                      /* Pointer to next physical value */
   double *px;                     /* Pointer to next x graphics value */
   double *py;                     /* Pointer to next y graphics value */

/* Convert the global "void *" pointer to a Map2Statics pointer */
   statics = (Map2Statics *) Map2_statics;

/* If zero points were supplied, release static resources and return. */
   if( n == 0 ){
      if( statics ) {
         if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
         if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
         Map2_statics = astFree( statics );
      }
      return;
   }

/* Otherwise, check the inherited global status. */
   if( !astOK ) return;

/* Create and initialise a structure to hold extra static information if
   this has not already been done. */
   if( !statics ) {
      statics = astMalloc( sizeof( Map2Statics ) );
      if( statics ) {
         statics->pset1 = NULL;
         statics->pset2 = NULL;
         statics->ptr2 = NULL;
         statics->ptr1[ 0 ] = NULL;
         statics->ptr1[ 1 ] = NULL;
         statics->nl = 0;
         Map2_statics = statics;
      }
   }

/* If the number of points to be mapped is different to last time,
   set up some PointSets to store the specified number of points. */
   if( n != statics->nl ){
      statics->nl = n;

/* Create a PointSet to hold the graphics coordinates corresponding to
   the supplied offsets. The supplied arrays will be used to hold the
   data for this PointSet, and so astGetPoints is not called. */
      if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
      statics->pset1 = astPointSet( n, 2, "", status );

/* Create a PointSet to hold the corresponding physical coordinates, and
   get pointers to the associated axis values. */
      if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
      statics->pset2 = astPointSet( n, Map2_ncoord, "", status );
      statics->ptr2 = astGetPoints( statics->pset2 );
    }


/* Check the initialisation went OK (if done). */
   if( astOK ){

/* Store pointers to the results arrays in PointSet 1. */
      statics->ptr1[ 0 ] = x;
      statics->ptr1[ 1 ] = y;
      astSetPoints( statics->pset1, statics->ptr1 );

/* Loop round each offset along the curve, converting the normalised offset
      in the range [0,1] to graphics coordinate and storing in PointSet 1. */
      px = x;
      py = y;
      for( i = 0; i < n; i++){
         *(px++) = Map2_x0 + Map2_deltax*dist[ i ];
         *(py++) = Map2_y0 + Map2_deltay*dist[ i ];
      }

/* Map all the positions into physical coordinates. */
      (void) Trans( Map2_plot, NULL, Map2_map, statics->pset1, 1, statics->pset2, 0, method, class, status );

/* Check the physical coordinates for bad values, setting the corresponding
   graphics coordinates bad. */
      for( j = 0; j < Map2_ncoord; j++ ){
         p = statics->ptr2[ j ];
         px = x;
         py = y;

         for( i = 0; i < n; i++){
            if( *(p++) == AST__BAD ){
               *(px++) = AST__BAD;
               *(py++) = AST__BAD;
            } else {
               px++;
               py++;
            }
         }
      }
   }

/* Return. */
   return;

}

static void Map3( int n, double *dist, double *x, double *y,
                  const char *method, const char *class,
                  int *status GLOBALS_ARG ){
/*
*  Name:
*     Map3

*  Purpose:
*     Find graphics coordinates at given distances along a geodesic curve
*     between two physical coordinate positions.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Map3( int n, double *dist, double *x, double *y,
*                const char *method, const char *class,
*                int *status [,AstGlobals *AST__GLOBALS] )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied distances are converted into physical offsets along the
*     geodesic curve joining the starting and finishing points given by
*     externals Map3_origin and Map3_end. The physical coordinates at these
*     offsets are found, and transformed into graphics coordinates.

*  Parameters:
*     n
*        The number of points to map. Static resources are released but
*        no points are mapped if zero is supplied.
*     dist
*        A pointer to an array holding "n" distances. A "dist" value of
*        zero corresponds to the starting position supplied in external
*        variable Map3_origin. A "dist" value of one corresponds to the
*        finishing position given by Map3_end.
*     x
*        A pointer to an array in which to store the "n" graphics X
*        coordinate values corresponding to the positions in "dist".
*     y
*        A pointer to an array in which to store the "n" graphics Y
*        coordinate values corresponding to the positions in "dist".
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.
*     AST__GLOBALS
*        Only present if compiled with -DTHREAD_SAFE. It is a pointer to
*        the structure holding the global data for the executing thread.
*        It is passed as a function parameter, rather than being accessed
*        within this function using the astGET_GLOBALS(NULL) macro (as
*        other Object-less functions do) in order to avoid the time
*        overheads of calling astGET_GLOBALS(NULL) . This function is
*        time-critical.

*  External Variables:
*     Map3_ncoord = int (Read)
*        The number of axes in the physical coordinate system.
*     Map3_origin = const double * (Read)
*        A pointer to an array holding the physical coordinate value on
*        each axis at the start of the curve (i.e. at dist = 0.0).
*     Map3_end = const double * (Read)
*        A pointer to an array holding the physical coordinate value on
*        each axis at the end of the curve (i.e. at dist = 1.0).
*     Map3_scale = double (Read)
*        The scale factor to convert "dist" values into physical offsets
*        along the geodesic curve.
*     Map3_statics = Map3Statics * (Read and Write)
*        Pointer to a structure holding other static data used by Map3.
*     Map3_plot = AstPlot * (Read)
*        A pointer to the Plot defining the mapping from graphics cordinates
*        to physical coordinates.
*     Map3_map = AstMapping * (Read)
*        A pointer to the mapping from graphics cordinates to physical
*        coordinates extracted from the Plot.
*     Map3_frame = AstFrame * (Read)
*        A pointer to the Current Frame in the Plot.

*  Notes:
*     -  On the first call, this function allocates static resources which
*     are used by subsequent invocation. These resources should be freed before
*     calling this function with new values for any of the external variables,
*     or when no longer needed, by calling this function with "n" supplied as
*     zero.
*     -  If an error has already occurred, this runction returns without
*     action ,except that if "n" is supplied as zero then static resources
*     are released even if an error has already occurred.

*/

/* Local Constants: */
   Map3Statics *statics;             /* Pointer to structure holding static data */
   int i, j;                         /* Loop counts */

/* Convert the global "void *" pointer to a Map3Statics pointer */
   statics = (Map3Statics *) Map3_statics;

/* If zero points were supplied, release static resources and return. */
   if( n == 0 ){
      if( statics ) {
         if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
         if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
         if( statics->pos ) statics->pos = (double *) astFree( (void *) statics->pos );
         Map3_statics = astFree( statics );
      }
      return;
   }

/* Otherwise, check the inherited global status. */
   if( !astOK ) return;

/* Create and initialise a structure to hold extra static information if
   this has not already been done. */
   if( !statics ) {
      statics = astMalloc( sizeof( Map3Statics ) );
      if( statics ) {
         statics->pset1 = NULL;
         statics->pset2 = NULL;
         statics->ptr1 = NULL;
         statics->ptr2[ 0 ] = NULL;
         statics->ptr2[ 1 ] = NULL;
         statics->nc = 0;
         statics->nl = 0;
         statics->pos = NULL;
         Map3_statics = statics;
      }
   }

/* If the number of points to be mapped is different to last time,
   set up some PointSets to store the specified number of points. */
   if( n != statics->nl ){
      statics->nl = n;

/* Create a PointSet to hold the physical coordinates corresponding to
   the supplied offsets. First annul any existing PointSet. */
      if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
      statics->pset1 = astPointSet( n, Map3_ncoord, "", status );
      statics->ptr1 = astGetPoints( statics->pset1 );

/* Create a PointSet to hold the corresponding graphics coordinates.
   The supplied "x" and "y" arrays will be used to store the data
   so we do not need to get pointers to the data using astGetPoints. First
   annul any existing PointSet. */
      if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
      statics->pset2 = astPointSet( n, 2, "", status );

   }

/* If the number of physical axes is different to last time,  allocate
   memory to hold a single physical position. */
   if( statics->nc != Map3_ncoord ){
      statics->nc = Map3_ncoord;
      statics->pos = (double *) astMalloc( sizeof(double)*(size_t)Map3_ncoord );
   }

/* Check the initialisation went OK (if done). */
   if( astOK ){

/* Loop round each offset along the curve, converting the normalised offset
   in the range [0,1] to a physical offset, and then into a physical
   position, and store in PointSet 1. */
      for( i = 0; i < n; i++){
         astOffset( Map3_frame, Map3_origin, Map3_end, Map3_scale*dist[ i ],
                    statics->pos );

         for( j = 0; j < Map3_ncoord; j++ ){
            statics->ptr1[ j ][ i ] = statics->pos[ j ];
         }

      }

/* Store pointers to the results arrays in PointSet 2. */
      statics->ptr2[ 0 ] = x;
      statics->ptr2[ 1 ] = y;
      astSetPoints( statics->pset2, statics->ptr2 );

/* Map all the positions into graphics coordinates. */
      (void) Trans( Map3_plot, NULL, Map3_map, statics->pset1, 0, statics->pset2, 1, method, class, status );
   }

/* Return. */
   return;

}

static void Map4( int n, double *dist, double *x, double *y,
                  const char *method, const char *class,
                  int *status GLOBALS_ARG ){
/*
*  Name:
*     Map4

*  Purpose:
*     Find graphics coordinates at given distances along a user
*     specified curve.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Map4( int n, double *dist, double *x, double *y,
*                const char *method, const char *class,
*                int *status [,AstGlobals *AST__GLOBALS] )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied distances are converted into physical coordinates using
*     the Mapping Map4_umap. These physical coordinates are transformed into
*     graphics coordinates.

*  Parameters:
*     n
*        The number of points to map. Static resources are released but
*        no points are mapped if zero is supplied.
*     dist
*        A pointer to an array holding "n" distances. A "dist" value of
*        zero corresponds to the starting position supplied in external
*        variable Map3_origin. A "dist" value of one corresponds to the
*        finishing position given by Map3_end.
*     x
*        A pointer to an array in which to store the "n" graphics X
*        coordinate values corresponding to the positions in "dist".
*     y
*        A pointer to an array in which to store the "n" graphics Y
*        coordinate values corresponding to the positions in "dist".
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.
*     AST__GLOBALS
*        Only present if compiled with -DTHREAD_SAFE. It is a pointer to
*        the structure holding the global data for the executing thread.
*        It is passed as a function parameter, rather than being accessed
*        within this function using the astGET_GLOBALS(NULL) macro (as
*        other Object-less functions do) in order to avoid the time
*        overheads of calling astGET_GLOBALS(NULL) . This function is
*        time-critical.

*  External Variables:
*     Map4_ncoord = int (Read)
*        The number of axes in the physical coordinate system.
*     Map4_plot = AstPlot * (Read)
*        A pointer to the Plot defining the mapping from graphics cordinates
*        to physical coordinates.
*     Map4_map = AstMapping * (Read)
*        A pointer to the mapping from graphics cordinates to physical
*        coordinates extracted from the Plot.
*     Map4_statics = Map4Statics * (Read and Write)
*        Pointer to a structure holding other static data used by Map4.
*     Map4_umap = AstMapping * (Read)
*        A pointer to the mapping from distance along the curve to physical
*        coordinates.

*  Notes:
*     -  On the first call, this function allocates static resources which
*     are used by subsequent invocation. These resources should be freed before
*     calling this function with new values for any of the external variables,
*     or when no longer needed, by calling this function with "n" supplied as
*     zero.
*     -  If an error has already occurred, this runction returns without
*     action ,except that if "n" is supplied as zero then static resources
*     are released even if an error has already occurred.

*/

/* Local Variables: */
   Map4Statics *statics;             /* Pointer to structure holding static data */
   double *ptr1[ 1 ];                /* Pointer to distances data */
   double *ptr3[ 2 ];                /* Pointers to graphics coord data */

/* Convert the global "void *" pointer to a Map4Statics pointer */
   statics = (Map4Statics *) Map4_statics;

/* If zero points were supplied, release static resources and return. */
   if( n == 0 ){
      if( statics ) {
         if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
         if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
         if( statics->pset3 ) statics->pset3 = astAnnul( statics->pset3 );
         Map4_statics = astFree( statics );
      }
      return;
   }

/* Otherwise, check the inherited global status. */
   if( !astOK ) return;

/* Create and initialise a structure to hold extra static information if
   this has not already been done. */
   if( !statics ) {
      statics = astMalloc( sizeof( Map4Statics ) );
      if( statics ) {
         statics->pset1 = NULL;
         statics->pset2 = NULL;
         statics->pset3 = NULL;
         statics->nl = 0;
         Map4_statics = statics;
      }
   }

/* If the number of points to be mapped is different to last time,
   set up some PointSets to store the specified number of points. */
   if( n != statics->nl ){
      statics->nl = n;

/* Create a PointSet to hold the distances along the curve. First annul any
   existing PointSet. */
      if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
      statics->pset1 = astPointSet( n, 1, "", status );

/* Create a PointSet to hold the physical coordinates corresponding to
   the supplied distances. First annul any existing PointSet. */
      if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
      statics->pset2 = astPointSet( n, Map4_ncoord, "", status );

/* Create a PointSet to hold the corresponding graphics coordinates.
   First annul any existing PointSet. */
      if( statics->pset3 ) statics->pset3 = astAnnul( statics->pset3 );
      statics->pset3 = astPointSet( n, 2, "", status );

   }

/* Check the initialisation went OK (if done). */
   if( astOK ){

/* Use Map4_umap to convert the supplied distances into physical coords
   (i.e. coords in the current Frame of the Plot). */
      ptr1[ 0 ] = dist;
      astSetPoints( statics->pset1, ptr1 );
      (void) astTransform( Map4_umap, statics->pset1, 1, statics->pset2 );

/* Store pointers to the results arrays in PointSet 2. */
      ptr3[ 0 ] = x;
      ptr3[ 1 ] = y;
      astSetPoints( statics->pset3, ptr3 );

/* Now transform these physical coords into graphical coords,
   incorporating clipping. */
      (void) Trans( Map4_plot, NULL, Map4_map, statics->pset2, 0, statics->pset3, 1, method, class, status );
   }

/* Return. */
   return;

}

static void Map5( int n, double *dist, double *x, double *y,
                  const char *method, const char *class,
                  int *status GLOBALS_ARG ){
/*
*  Name:
*     Map5

*  Purpose:
*     Find graphics coordinates at given distances along the boundary of
*     a Region.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Map5( int n, double *dist, double *x, double *y,
*                const char *method, const char *class,
*                int *status [,AstGlobals *AST__GLOBALS] )

*  Class Membership:
*     Plot member function.

*  Description:
*     The supplied distances are converted into physical coordinates
*     using the Region specified by an external variable, and then
*     these physical coordinates are mapped into graphics coordinates.

*  Parameters:
*     n
*        The number of points to map. Static resources are released but
*        no points are mapped if zero is supplied.
*     dist
*        A pointer to an array holding "n" distances. A "dist" value of
*        zero corresponds to the starting position supplied in external
*        variable Map1_origin. A "dist" value of one corresponds to the
*        finishing position which is a distance Map1_length away from
*        Map1_origin, moving in the positive direction of the axis given
*        by Map1_axis. "dist" values can be either linearly or
*        logarithmically related to axis values (see Map1_log).
*     x
*        A pointer to an array in which to store the "n" graphics X
*        coordinate values corresponding to the positions in "dist".
*     y
*        A pointer to an array in which to store the "n" graphics Y
*        coordinate values corresponding to the positions in "dist".
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.
*     AST__GLOBALS
*        Only present if compiled with -DTHREAD_SAFE. It is a pointer to
*        the structure holding the global data for the executing thread.
*        It is passed as a function parameter, rather than being accessed
*        within this function using the astGET_GLOBALS(NULL) macro (as
*        other Object-less functions do) in order to avoid the time
*        overheads of calling astGET_GLOBALS(NULL) . This function is
*        time-critical.

*  External Variables:
*     Map1_log = int (Read)
*        If zero, then "dist" in learly related to axis value. Otherwise
*        it is linearly related to log10(axis value).
*     Map1_ncoord = int (Read)
*        The number of axes in the physical coordinate system.
*     Map1_axis = int (Read)
*        The zero-based index of the axis which the curve follows (i.e.
*        the axis which changes value along the curve).
*     Map1_statics = Map1Statics * (Read and Write)
*        Pointer to a structure holding other static data used by Map1.
*     Map1_origin = const double * (Read)
*        A pointer to an array holding the physical coordinate value on
*        each axis at the start of the curve (i.e. at dist = 0.0).
*     Map1_length = double (Read)
*        The scale factor to convert "dist" values into increments
*        along the physical axis given by Map1_axis.
*     Map1_plot = AstPlot * (Read)
*        A pointer to the Plot defining the mapping from graphics cordinates
*        to physical coordinates.
*     Map1_map = AstMapping * (Read)
*        A pointer to the mapping from graphics cordinates to physical
*        coordinates extracted from the Plot.
*     Map1_frame = AstFrame * (Read)
*        A pointer to the Current Frame in the Plot.
*     Map1_norm = int (Read)
*        A flag indicating if physical coordinate values which are not in
*        the normal ranges of the corresponding axes should be considered
*        bad.

*  Notes:
*     -  On the first call, this function allocates static resources which
*     are used by subsequent invocation. These resources should be freed before
*     calling this function with new values for any of the external variables,
*     or when no longer needed, by calling this function with "n" supplied as
*     zero.
*     -  If an error has already occurred, this runction returns without
*     action ,except that if "n" is supplied as zero then static resources
*     are released even if an error has already occurred.

*/

/* Local Constants: */
   Map5Statics *statics;             /* Pointer to structure holding static data */

/* Convert the global "void *" pointer to a Map5Statics pointer */
   statics = (Map5Statics *) Map5_statics;

/* If zero points were supplied, release static resources and return. */
   if( n == 0 ){
      if( statics ) {
         if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
         if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
         Map5_statics = astFree( statics );
      }
      return;
   }

/* Otherwise, check the inherited global status. */
   if( !astOK ) return;

/* Create and initialise a structure to hold extra static information if
   this has not already been done. */
   if( !statics ) {
      statics = astMalloc( sizeof( Map3Statics ) );
      if( statics ) {
         statics->pset1 = NULL;
         statics->pset2 = NULL;
         statics->ptr1 = NULL;
         statics->ptr2[ 0 ] = NULL;
         statics->ptr2[ 1 ] = NULL;
         statics->nl = 0;
         Map5_statics = statics;
      }
   }

/* If the number of points to be mapped is different to last time,
   set up some PointSets to store the specified number of points. */
   if( n != statics->nl ){
      statics->nl = n;

/* Create a PointSet to hold the physical coordinates corresponding to
   the supplied offsets. First annul any existing PointSet. */
      if( statics->pset1 ) statics->pset1 = astAnnul( statics->pset1 );
      statics->pset1 = astPointSet( n, Map5_ncoord, "", status );
      statics->ptr1 = astGetPoints( statics->pset1 );

/* Create a PointSet to hold the corresponding graphics coordinates.
   The supplied "x" and "y" arrays will be used to store the data
   so we do not need to get pointers to the data using astGetPoints. First
   annul any existing PointSet. */
      if( statics->pset2 ) statics->pset2 = astAnnul( statics->pset2 );
      statics->pset2 = astPointSet( n, 2, "", status );
   }

/* Get the physical coords at the required positions along the Region
   border. */
   astRegTrace( Map5_region, n, dist, statics->ptr1 );

/* Store pointers to the results arrays in PointSet 2. */
   statics->ptr2[ 0 ] = x;
   statics->ptr2[ 1 ] = y;
   astSetPoints( statics->pset2, statics->ptr2 );

/* Map all the positions into graphics coordinates. */
   (void) Trans( Map5_plot, NULL, Map5_map, statics->pset1, 0,
                 statics->pset2, 1, method, class, status );

/* Return. */
   return;
}

static void Mark( AstPlot *this, int nmark, int ncoord, int indim,
                  const double *in, int type, int *status ){
/*
*++
*  Name:
c     astMark
f     AST_MARK

*  Purpose:
*     Draw a set of markers for a Plot.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astMark( AstPlot *this, int nmark, int ncoord, int indim,
c                   const double *in, int type )
f     CALL AST_MARK( THIS, NMARK, NCOORD, INDIM, IN, TYPE, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function draws a set of markers (symbols) at positions
f     This routine draws a set of markers (symbols) at positions
*     specified in the physical coordinate system of a Plot. The
*     positions are transformed into graphical coordinates to
*     determine where the markers should appear within the plotting
*     area.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     nmark
f     NMARK = INTEGER (Given)
*        The number of markers to draw. This may be zero, in which
*        case nothing will be drawn.
c     ncoord
f     NCOORD = INTEGER (Given)
*        The number of coordinates being supplied for each mark
*        (i.e. the number of axes in the current Frame of the Plot, as
*        given by its Naxes attribute).
c     indim
f     INDIM = INTEGER (Given)
c        The number of elements along the second dimension of the "in"
f        The number of elements along the first dimension of the IN
*        array (which contains the marker coordinates). This value is
*        required so that the coordinate values can be correctly
*        located if they do not entirely fill this array. The value
c        given should not be less than "nmark".
f        given should not be less than NMARK.
c     in
f     IN( INDIM, NCOORD ) = DOUBLE PRECISION (Given)
c        The address of the first element of a 2-dimensional array of
c        shape "[ncoord][indim]" giving the
c        physical coordinates of the points where markers are to be
c        drawn. These should be stored such that the value of
c        coordinate number "coord" for input mark number "mark" is
c        found in element "in[coord][mark]".
f        A 2-dimensional array giving the physical coordinates of the
f        points where markers are to be drawn. These should be
f        stored such that the value of coordinate number COORD for
f        input mark number MARK is found in element IN(MARK,COORD).
c     type
f     TYPE = INTEGER (Given)
*        A value specifying the type (e.g. shape) of marker to be
*        drawn. The set of values which may be used (and the shapes
*        that will result) is determined by the underlying graphics
*        system.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - Markers are not drawn at positions which have any coordinate
*     equal to the value AST__BAD (or where the transformation into
*     graphical coordinates yields coordinates containing the value
*     AST__BAD).
c     - If any marker position is clipped (see astClip), then the
f     - If any marker position is clipped (see AST_CLIP), then the
*     entire marker is not drawn.
*     - An error results if the base Frame of the Plot is not 2-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   AstMapping *mapping;    /* Pointer to graphics->physical mapping */
   AstPointSet *pset1;     /* PointSet holding physical positions */
   AstPointSet *pset2;     /* PointSet holding graphics positions */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   const double **ptr1;    /* Pointer to physical positions */
   double **ptr2;          /* Pointer to graphics positions */
   double *xpd;            /* Pointer to next double precision x value */
   double *ypd;            /* Pointer to next double precision y value */
   double xx;              /* X axis value */
   double yy;              /* Y axis value */
   float *x;               /* Pointer to single precision x values */
   float *xpf;             /* Pointer to next single precision x value */
   float *y;               /* Pointer to single precision y values */
   float *ypf;             /* Pointer to next single precision y value */
   int axis;               /* Axis index */
   int clip;               /* Clips marks at plot boundary? */
   int i;                  /* Loop count */
   int naxes;              /* No. of axes in the base Frame */
   int nn;                 /* Number of good marker positions */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astMark";
   class = astClass( this );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Also validate the input array dimension argument. */
   if ( astOK && ( indim < nmark ) ) {
      astError( AST__DIMIN, "%s(%s): The input array dimension value "
                "(%d) is invalid.", status, method, class, indim );
      astError( AST__DIMIN, "This should not be less than the number of "
                "markers being drawn (%d).", status, nmark );
   }

/* Initialise the bounding box for primatives produced by this call. */
   if( !Boxp_freeze ) {
      Boxp_lbnd[ 0 ] = FLT_MAX;
      Boxp_lbnd[ 1 ] = FLT_MAX;
      Boxp_ubnd[ 0 ] = FLT_MIN;
      Boxp_ubnd[ 1 ] = FLT_MIN;
   }

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
   astGrfAttrs( this, AST__MARKS_ID, 1, GRF__MARK, method, class );

/* Create a PointSet to hold the supplied physical coordinates. */
   pset1 = astPointSet( nmark, ncoord, "", status );

/* Allocate memory to hold pointers to the first value on each axis. */
   ptr1 = (const double **) astMalloc( sizeof( const double * )*
                                       (size_t)( ncoord ));

/* Check the pointer can be used, then store pointers to the first value
   on each axis. */
   if( astOK ){
      for( axis = 0; axis < ncoord; axis++ ){
         ptr1[ axis ] = in + axis*indim;
      }
   }

/* Store these pointers in the PointSet. */
   astSetPoints( pset1, (double **) ptr1 );

/* Transform the supplied data from the current frame (i.e. physical
   coordinates) to the base frame (i.e. graphics coordinates) using
   the inverse Mapping defined by the Plot. */
   mapping = astGetMapping( this, AST__BASE, AST__CURRENT );
   pset2 = Trans( this, NULL, mapping, pset1, 0, NULL, 0, method, class, status );
   mapping = astAnnul( mapping );

/* Get pointers to the graphics coordinates. */
   ptr2 = astGetPoints( pset2 );

/* Allocate memory to hold single precision versions of the graphics
   coordinates. */
   x = (float *) astMalloc( sizeof( float )*(size_t) nmark );
   y = (float *) astMalloc( sizeof( float )*(size_t) nmark );

/* Check the pointers can be used. */
   if( astOK ){

/* Store pointers to the next single and double precision x and y
   values. */
      xpf = x;
      ypf = y;
      xpd = ptr2[ 0 ];
      ypd = ptr2[ 1 ];

/* Convert the double precision values to single precision, rejecting
   any bad marker positions. If clipping is switched on, also clip any
   markers with centres outside the plotting area. */
      clip = astGetClip( this ) & 2;
      nn = 0;
      for( i = 0; i < nmark; i++ ){
         if( *xpd != AST__BAD && *ypd != AST__BAD ){
            xx = *(xpd++);
            yy = *(ypd++);
            if( !clip || ( xx >= this->xlo && xx <= this->xhi &&
                           yy >= this->ylo && yy <= this->yhi ) ) {
               nn++;
               *(xpf++) = (float) xx;
               *(ypf++) = (float) yy;
            }
         } else {
            xpd++;
            ypd++;
         }
      }

/* Draw the remaining markers. */
      GMark( this, nn, x, y, type, method, class, status );

   }

/* Free the memory used to store single precision graphics coordinates. */
   x = (float *) astFree( (void *) x );
   y = (float *) astFree( (void *) y );

/* Annul the PointSets. */
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

/* Free the memory holding the pointers to the first value on each axis. */
   ptr1 = (const double **) astFree( (void *) ptr1 );

/* Re-establish the original graphical attributes. */
   astGrfAttrs( this, AST__MARKS_ID, 0, GRF__MARK, method, class );

/* Return */
   return;
}

static void Mirror( AstPlot *this, int axis, int *status ){
/*
*+
*  Name:
*     astMirror

*  Purpose:
*     Flip a graphics axis of a Plot.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot.h"
*     void astMirror( AstPlot *this, int axis )

*  Class Membership:
*     Plot method.

*  Description:
*     This function referses the direction of a specified graphics axis
*     in the Plot.

*  Parameters:
*     this
*        Pointer to a Plot.
*     axis
*        The zero-based axis of the axis to mirror.

*-
*/

/* Check the global status. */
   if( !astOK ) return;

   if( axis == 0 ) {
      this->xrev = ( this->xrev == 0 );

   } else if( axis == 1 ){
      this->yrev = ( this->yrev == 0 );

   } else {
      astError( AST__INTER, "astMirror(%s): Illegal axis index (%d) "
                "supplied (internal AST programming error).", status,
                astGetClass( this ), axis );
   }
}

static void Norm1( AstMapping *map, int axis, int nv, double *vals,
                   double refval, double width, int *status ){
/*
*  Name:
*     Norm1

*  Purpose:
*     Use a Mapping to normalize an array of axis values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Norm1( AstMapping *map, int axis, int nv, double *vals,
*                 double refval, double width, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     The normalization of a position in physical space has two parts;
*     firstly, the Mapping may determine a form of normalization;
*     secondly, the Frame may provide an additional normalizion by the
*     astNorm method. This function implements normalization using a
*     Mapping, by transforming the physical position into Graphics position,
*     and then back into a physical position. For instance, if the Mapping
*     represents a mapping of Cartesian graphics axes onto a 2D polar
*     coordinate system, a physical theta value of 3.PI will be normalized by
*     the Mapping into a theta value of 1.PI (probably, but it depends on
*     the Mapping). In this case, the Mapping normalization may well be the
*     only normalization available, since the 2D polar coord. system will
*     probably use a simple Frame to represent the (radius,theta) system,
*     and a simple Frame defines no normalization (i.e. the astNorm method
*     returns the supplied position unchanged).
*
*     Complications arise though because it is not possible to normalise
*     a single axis value - you can only normalize a complete position.
*     Therefore some value must be supplied for the other axis. We
*     should use the LabelAt value, but we do not yet know what the LabelAt
*     value will be. Instead, we try first using the supplied "refval"
*     which should be close to the mode of the other aixs values. Usually
*     the value used is not very important. However, for some complex
*     projections (such as quad-cubes, TSC, etc) the choice can be more
*     critical since some positions on the ksy correspond to undefined
*     graphics positions (e.g the face edges in a TSC projection).
*     Therefore, if the supplied refval results in any positions being
*     undefined we refine the process by transforming the undefined
*     positaons again using a different refval. We do this twice to bump
*     up the likelihood of finding a suitable reference value.

*  Parameters:
*     mapping
*        The Mapping from Graphics Frame to the current Frame.
*     axis
*        The index of the axis for which values are supplied in "vals".
*     nv
*        The number of values supplied in "vals".
*     vals
*        Pointer to an array of axis values. On exit they are normalized.
*     refval
*        The preffered constant value to use for the other axis when
*        normalizing the values in "vals".
*     width
*        The range of used values for the other axis.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstPointSet *pset1;        /* PointSet holding physical coords */
   AstPointSet *pset2;        /* PointSet holding graphics coords */
   double **ptr1;             /* Pointer to physical coords data */
   double *a;                 /* Pointer to next axis value */
   double *b;                 /* Pointer to next axis value */
   int i;                     /* Loop count */
   int itry;                  /* Loop count for re-try loop */
   int nbad;                  /* No. of bad values found after transformation */
   int *flags;                /* Pointer to flags array */

/* Check the inherited global status. */
   if( !astOK ) return;

/* Store the supplied positions in a PointSet. */
   pset1 = astPointSet( nv, 2, "", status );
   ptr1 = astGetPoints( pset1 );
   if( astOK ) {
      a = ptr1[ axis ];
      b = ptr1[ 1 - axis ];
      for( i = 0; i < nv; i++){
         *(a++) = vals[ i ];
         *(b++) = refval;
      }
   }

/* Transform the supplied positions into the Base Frame. */
   pset2 = astTransform( map, pset1, 0, NULL );

/* Transform the Base Frame positions back into the Current Frame. */
   (void) astTransform( map, pset2, 1, pset1 );

/* Allocate memory to hold a flag for each position which is non-zero if
   we currently have a good axis value to return for the position. */
   flags = (int *) astMalloc( sizeof(int)* (size_t) nv );

/* If good, store these values back in the supplied array. If the
   transformed values are bad, retain the original good values for the
   moment in "vals", and also copy the good values back into pset1. So
   at the end, pset1 will contain the original good values at any points
   which produced bad values after the above transformation - the other
   points in pset1 will be bad.  */
   nbad = 0;
   if( astOK ) {
      a = ptr1[ axis ];
      for( i = 0; i < nv; i++, a++ ){
         if( *a != AST__BAD ) {
            vals[ i ] = *a;
            *a = AST__BAD;
            flags[ i ] = 1;
         } else if( vals[ i ] != AST__BAD ) {
            nbad++;
            *a = vals[ i ];
            flags[ i ] = 0;
         } else {
            flags[ i ] = 1;
         }
      }
   }

/* We now try normalising any remaining bad positions using different
   values for the other axis. This may result in some or all of the
   remaining points being normalised succesfully. */
   for( itry = 0; itry < 10; itry++ ) {

/* If the above transformation produced any bad values, try again with a
   different value on the other axis. */
      if( astOK && nbad > 0 ) {
         b = ptr1[ 1 - axis ];
         for( i = 0; i < nv; i++){
            *(b++) = refval + 0.1*( itry + 1 )*width;
         }

/* Transform to graphics coords and back to world coords. */
         (void) astTransform( map, pset1, 0, pset2 );
         (void) astTransform( map, pset2, 1, pset1 );

/* Copy any good positions back into the returned vals array. Count
   remaining bad positions. */
         a = ptr1[ axis ];
         nbad = 0;
         for( i = 0; i < nv; i++, a++ ){
            if( *a != AST__BAD ) {
               vals[ i ] = *a;
               flags[ i ] = 1;
               *a = AST__BAD;
            } else if( !flags[ i ] ) {
               nbad++;
               *a = vals[ i ];
            }
         }
      }

/* If the above transformation produced any bad values, try again with a
   different value on the other axis. */
      if( astOK && nbad > 0 ) {
         b = ptr1[ 1 - axis ];
         for( i = 0; i < nv; i++){
            *(b++) = refval - 0.1*( itry + 1 )*width;
         }

/* Transform to graphics coords and back to world coords. */
         (void) astTransform( map, pset1, 0, pset2 );
         (void) astTransform( map, pset2, 1, pset1 );

/* Copy any good positions back into the returned vals array. Count
   remaining bad positions. */
         a = ptr1[ axis ];
         nbad = 0;
         for( i = 0; i < nv; i++, a++ ){
            if( *a != AST__BAD ) {
               vals[ i ] = *a;
               flags[ i ] = 1;
               *a = AST__BAD;
            } else if( !flags[ i ] ) {
               nbad++;
               *a = vals[ i ];
            }
         }
      }
   }

/* Free resources. */
   flags = (int *) astFree( flags );
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

}

static void Opoly( AstPlot *this, int *status ){
/*
*  Name:
*     Opoly

*  Purpose:
*     Draws the current poly line.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Opoly( AstPlot *this, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws the current poly line, and empties the buffer.

*  Parameters:
*     this
*        Pointer to the Plot.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int ipoly;              /* Index of new polyline */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */

/* Check the global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Draw the poly-line if needed. */
   if( Poly_n > 0 ) {

/* Extend the global arrays that hold pointers to the polylines already
   drawn. */
      ipoly = Poly_npoly++;
      astBeginPM;
      Poly_xp = astGrow( Poly_xp, Poly_npoly, sizeof(float*) );
      Poly_yp = astGrow( Poly_yp, Poly_npoly, sizeof(float*) );
      Poly_np = astGrow( Poly_np, Poly_npoly, sizeof(int) );
      astEndPM;

      if( astOK ) {

/* Add pointers to the new polyline to the end of the above extended
   arrays. */
         Poly_xp[ ipoly ] = Poly_x;
         Poly_yp[ ipoly ] = Poly_y;
         Poly_np[ ipoly ] = Poly_n;

/* Indicate that the current polyline is now empty. */
         Poly_x = NULL;
         Poly_y = NULL;
         Poly_n = 0;
      }
   }
}

static int Overlap( AstPlot *this, int mode, int esc, const char *text, float x,
                    float y, const char *just, float upx, float upy,
                    float **work, const char *method, const char *class, int *status ){
/*
*  Name:
*     Overlap

*  Purpose:
*     See if a major tick value label would overlap any of the previously
*     drawn labels.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Overlap( AstPlot *this, int mode, int esc, const char *text, float x,
*                  float y, const char *just, float upx, float upy,
*                  float **work, const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     The operation of this function is determined by the "mode" parameter.

*     A record is kept of the bounding boxes enclosing all the displayed
*     labels. If the bounding box of the new label defined by the given
*     parameter values would overlap any of the old bounding boxes, 0 is
*     returned. Otherwise 1 is returned and the bounding box for the new
*     label is added to the list of old bounding boxes.

*     This function also updates the external variables Box_lbnd and
*     Box_ubnd which hold the lower and upper bounds of the area enclosing
*     all used labels.

*  Parameters:
*     this
*        A pointer to the Plot.
*     mode
*        - If -1, find the bounding box of the supplied label, add it
*        to the list of stored bounding box, and return 1 if it overlaps
*        any previously stored bounding boxes.
*        - If -2, leave the bounding boxes unchanged and return the
*        number of bounding boxes currently stored. No other action is taken
*        and all other arguments are ignored.
*        - Otherwise, reset the number of stored bounding boxes to the
*        value of mode, and return the new number of bounding boxes. No
*        action is taken if mode is less than zero or greater than the current
*        number of stored boxes. No other action is taken and all other
*        arguments are ignored.
*     esc
*        Should escape sequences in the text be interpreted?
*     text
*        A pointer to the label text string.
*     x
*        The graphics X coordinate of the label's reference point.
*     y
*        The graphics Y coordinate of the label's reference point.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text.
*     upy
*        The y component of the up-vector for the text.
*     work
*        A pointer to a place at which to store a pointer to an array of
*        floats holding the old bounding boxes. Memory to hold this array
*        is allocated automatically within this function. The pointer to
*        the array should be supplied as NULL on the first call to this
*        function, and the array should be freed using astFree when no
*        longer needed.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     See parameter "mode."

*  Notes:
*     -  Zero is returned if an error has occurred, or if this function
*     should fail for any reason.

*/

/* Local Variables: */
   astDECLARE_GLOBALS     /* Pointer to thread-specific global data */
   int nbox = 0;          /* Number of boxes stored in "work" */
   int ret;               /* Does the new label overlap a previous label? */
   int i;                 /* Box index */
   float *cx;             /* Pointer to next corner's X value */
   float *cy;             /* Pointer to next corner's Y value */
   float xbn[ 4 ];        /* X coords at corners of new label's bounding box */
   float ybn[ 4 ];        /* Y coords at corners of new label's bounding box */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Initialise the returned value to indicate no overlap has been found. */
   ret = 0;

/* Get the number of bounding boxes in the supplied work array. */
   if( work && *work ) {
      nbox = (*work)[ 0 ];
   } else {
      nbox = 0;
   }

/* If required, return the number of bounding boxes currently stored. */
   if( mode == -2 ) return nbox;

/* If required, reset the number of bounding boxes currently stored, and
   return the new number. */
   if( mode >= 0 ) {
      if( mode < nbox && work && *work ) {
         nbox = mode;
         (*work)[ 0 ] = nbox;
      }
      return nbox;
   }

/* If no work array has been supplied, allocate one now with room for
   10 boxes. Each box requires 8 floats, 2 for each of the 4 corners. The
   X graphics coordinates at the 4 corners are stored in the first 4 floats,
   and the corresponding Y graphics coordinates in the second group of 4
   floats. */
   if( work && !(*work) ) {
      *work = (float *) astMalloc( 81*sizeof(float) );
      if( astOK ) {
         nbox = 0;
         (*work)[ 0 ] = 0;
      }
   }

/* Check the global status. */
   if( !astOK ) return ret;

/* Get the bounds of the box containing the new label. */
   DrawText( this, 0, esc, text, x, y, just, upx, upy,
             xbn, ybn, NULL, method, class, status );

/* If the bounding box was obtained succesfully... */
   if( astOK ) {

/* Check for an overlap between the box and each of the previous boxes. */
      cx = *work + 1;
      cy = cx + 4;
      for( i = 0; i < nbox; i++ ){

         if( BoxCheck( xbn, ybn, cx, cy, status ) ) {
            ret = 1;
            break;
         }

/* Increment the pointers to the next box. */
         cx += 8;
         cy += 8;

      }

/* If no overlap was found, add the new box to the list. */
      if( !ret ){
         *work = (float *) astGrow( (void *) *work, 8*nbox + 9, sizeof(float) );
         cx = *work + 1 + 8*nbox;
         cy = cx + 4;
         for( i = 0; i < 4; i++ ){
            cx[ i ] = xbn[ i ];
            cy[ i ] = ybn[ i ];
         }
         (*work)[ 0 ]++;

/* Extend the bounds of the global bounding box held externally to include
   the new box. */
         for( i = 0; i < 4; i++ ){
            Box_lbnd[ 0 ] = astMIN( xbn[ i ], Box_lbnd[ 0 ] );
            Box_ubnd[ 0 ] = astMAX( xbn[ i ], Box_ubnd[ 0 ] );
            Box_lbnd[ 1 ] = astMIN( ybn[ i ], Box_lbnd[ 1 ] );
            Box_ubnd[ 1 ] = astMAX( ybn[ i ], Box_ubnd[ 1 ] );
         }
      }
   }

/* If an error has occur, return a value of 0. */
   if( !astOK ) ret = 0;

/* Return the answer. */
   return ret;

}

static void PlotLabels( AstPlot *this, int esc, AstFrame *frame, int axis,
                        LabelList *list, char *fmt, int nlab, float **box,
                        const char *method, const char *class, int *status ) {
/*
*
*  Name:
*     PlotLabels

*  Purpose:
*     Draws the numerical labels which have been selected for display.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void PlotLabels( AstPlot *this, int esc, AstFrame *frame, int axis,
*                      LabelList *list, char *fmt, int nlab, float **box,
*                      const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function displays the numerical labels supplied in the
*     structure pointed to by "list". Overlapping labels are omitted,
*     and redundant leading fields are removed from adjacent labels.
*     Nothing is plotted if the NumLab attribute for the axis is false.

*  Parameters:
*     this
*        A pointer to the Plot.
*     esc
*        Interpret escape sequences in labels?
*     frame
*        A pointer to the current Frame of the Plot.
*     axis
*        The axis index (0 or 1).
*     list
*        A pointer to the LabelList structure holding information about
*        the selected numerical labels.
*     fmt
*        A pointer to a null terminated string holding the format
*        specification used to create the labels.
*     nlab
*        The number of labels described by "list".
*     box
*        A pointer to a place at which to store a pointer to an array of
*        floats holding the bounding boxes of displayed labels. Memory to
*        hold this array is allocated automatically within this function.
*        The pointer to the array should be supplied as NULL on the first
*        call to this function, and the array should be freed using astFree
*        when no longer needed.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   LabelList *ll;         /* Pointer to next label structure */
   LabelList *llhi;       /* Pointer to higher neighbouring label structure */
   LabelList *lllo;       /* Pointer to lower neighbouring label structure */
   char *text;            /* Pointer to label text */
   const char *latext;    /* Axis label at previous label */
   const char *texthi;    /* Pointer to text abbreviated with higher neighbour */
   const char *textlo;    /* Pointer to text abbreviated with lower neighbour */
   float tolx;            /* Min allowed X interval between labels */
   float toly;            /* Min allowed Y interval between labels */
   float xbn[ 4 ];        /* X coords at corners of new label's bounding box */
   float ybn[ 4 ];        /* Y coords at corners of new label's bounding box */
   int abb;               /* Abbreviate leading fields? */
   int dp;                /* Number of decimal places */
   int found;             /* Non-zero digit found? */
   int hilen;             /* Length of texthi */
   int i;                 /* Label index */
   int j;                 /* Label index offset */
   int jgap;              /* Gap in index between rejected labels */
   int lab0;              /* Index of middle label */
   int lolen;             /* Length of textlo */
   int mxdp;              /* Maximum number of decimal places */
   int nbox;              /* The number of boinding boxes supplied */
   int nexti;             /* Index of next label to retain */
   int nleft;             /* No. of labels left */
   int nz;                /* Number of trailing zeros in this label */
   int nzmax;             /* Max. number of trailing zeros */
   int odd;               /* DO we have a strange axis? */
   int off;               /* Offset from central label */
   int olap;              /* Any overlap found? */
   int prio;              /* Current priority */
   int root;              /* Index of unabbreviated label */
   int root_found;        /* Has the root label been decided on? */
   int rootoff;           /* Distance from middle to root label */
   int split;             /* Indicates whether to split labels into 2 lines */

/* Return without action if an error has occurred, or there are no labels to
   draw. */
   if( !astOK || nlab == 0 || !list || !astGetNumLab( this, axis ) ) return;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   rootoff = 0;

/* Get the number of bounding boxes describing the labels already drawn
   (this will be non-zero only if this is the second axis to be labelled). */
   nbox = Overlap( this, -2, 0, NULL, 0.0, 0.0, NULL, 0.0, 0.0, box, method,
                   class, status );

/* Ensure the labels are sorted into increasing index order. */
   qsort( (void *) list, (size_t) nlab, sizeof(LabelList), Compare_LL );

/* Complex curves can have multiple edge crossings very close together.
   This means that the same label can sometimes be included more than once
   in the supplied list at the same (x,y) position. Purge duplicate labels
   by setting their priority to -1. Initialise the priority of the remaining
   labels to zero. */
   tolx = 0.02*fabs( this->xhi - this->xlo );
   toly = 0.02*fabs( this->yhi - this->ylo );
   ll = list;
   ll->priority = 0;
   ll->saved_prio = 0;

   for( i = 1; i < nlab; i++ ) {
      ll++;
      ll->priority = 0;
      ll->saved_prio = 0;
      for( j = 0; j < i; j++ ){
         if( !strcmp( ll->text, list[ j ].text ) ) {
            if( fabs( ll->x - list[ j ].x ) < tolx &&
                fabs( ll->y - list[ j ].y ) < toly ) {
               ll->priority = -1;
               ll->saved_prio = -1;
               break;
            }
         }
      }
   }

/* Find the maximum number of decimal places in any label. */
   mxdp = 0;
   ll = list - 1;
   for( i = 0; i < nlab; i++ ) {
      ll++;
      FindDPTZ( frame, axis, fmt, ll->text, &dp, &nz, status );
      if( dp > mxdp ) mxdp = dp;
   }

/* Indicate that we do not yet know whether SplitValue should split labels
   into two lines or not. */
   split = 0;

/* Find the highest priority label (the "root" label). This label is
   never abbreviated to remove leading fields, and is never omitted due to
   overlaps with other labels. To find this label, each label is assigned a
   priority equal to the number of trailing zeros in the label text. If the
   text has fewer than the maximum number of decimal places, pretend the text
   is padded with trailing zeros to bring the number of decimal places up to
   the maximum. The root label is the highest priority label, giving
   preference to labels which occur in the middle of the index order. At the
   same time, initialize the abbreviated text for each label to be equal to
   the unabbreviated text. */
   lab0 = nlab/2;
   nzmax = -1;
   ll = list - 1;
   root = -1;
   root_found = 0;
   for( i = 0; i < nlab; i++ ) {
      ll++;
      if( ll->priority > -1 ) {
         text = ll->text;

/* Find the number of decimal places and the number of trailing zeros in
   this label. Note if a non-zero digit was found in the label. */
         found = FindDPTZ( frame, axis, fmt, text, &dp, &nz, status );

/* Add on some extra trailing zeros to make the number of decimal places
   up to the maximum value. */
         nz += mxdp - dp;

/* Store the priority for this label. */
         ll->priority = nz;
         ll->saved_prio = nz;

/* Note the highest priority of any label. */
         if( nz > nzmax ) nzmax = nz;

/* We will use this label as the root label if:

   - We have not already found the root label

   AND

   - It does not overlap any labels drawn for a previous axis

   AND

   - We do not currently have a candidate root label, or
   - The priority for this label is higher than the priority of the current
   root label, or
   - The priority for this label is equal to the priority of the current
   root label and this label is closer to the centre of the axis, or
   - The label value is zero.  */

         if( root == -1 ||
             nz > list[ root ].priority ||
             ( nz == list[ root ].priority && abs( i - lab0 ) < rootoff ) ||
             !found ) {

            if( !root_found ) {

               if( axis == 0 || !Overlap( this, -1, esc,
                                          SplitValue( this, ll->text,
                                                      axis, &split, status ),
                                          (float) ll->x, (float) ll->y,
                                          ll->just, (float) ll->upx,
                                          (float) ll->upy, box, method,
                                          class, status ) ) {
                  root = i;
                  rootoff = abs( i - lab0 );

/* If the label value was zero, we will use label as the root label,
   regardless of the priorities of later labels. */
                  if( !found ) root_found = 1;
               }

/* Reset the list of bounding boxes to exclude any box added above. */
               Overlap( this, nbox, esc, NULL, 0.0, 0.0, NULL, 0.0, 0.0, box,
                        method, class, status );

            }
         }
      }

/* Initialise the abbreviated text to be the same as the full text. */
      ll->atext = ll->text;
   }

/* If all the labels overlapped labels on a previous axis, arbitrarily
   use the label with non-genative priority that is closest to the middle
   as the root label (this should never happen but is included to avoid
   segmentation violations occurring in error conditions such as the
   txExt function being buggy and cuasing spurious overlaps). */
   if( root == -1 ) {
      for( off = 0; off < (nlab-1)/2; off++ ) {
         root = nlab/2 + off;
         if( list[ root ].priority >= 0 ) break;
         root = nlab/2 - off;
         if( list[ root ].priority >= 0 ) break;
      }
      if( root == -1 ) {
         astError( AST__PLFMT, "%s(%s): Cannot produce labels for axis %d.",
                   status, method, class, axis + 1 );
         root = nlab/2;
      }
   }

/* Assign a priority higher than any other priority to the root label. */
   list[ root ].priority = nzmax + 1;
   list[ root ].saved_prio = nzmax + 1;

/* See if leading fields are to be abbreviated */
   abb = astGetAbbrev( this, axis );

/* The following process may have removed some labels which define the
   missing fields in neighbouring abbreviated fields, so that the user
   would not be able to tell what value the abbvreviated leading fields
   should have. We therefore loop back and perform the abbreviation
   process again, omitting the removed labels this time. Continue doing
   this until no further labels are removed. */
   jgap = 1;
   olap = 1;
   odd = 0;
   while( olap && !odd ) {

/* We now attempt to abbreviate the remaining labels (i.e. those which
   have not been rejected on an earlier pass through this loop). Labels
   are abbreviated in order of their priority. Higher priority labels are
   abbreviated first (except that the root label, which has the highest
   priority, is never abbreviated). Each label is abbreviated by comparing
   it with the nearest label with a higher priority. */

/* Loop through all the priority values, starting with the highest
   priority (excluding the root label so that the root label is never
   abbreviated), and working downwards to finish with zero priority. */
      prio = nzmax + 1;
      while( prio-- > 0 ) {

/* Look for labels which have the current priority. */
         ll = list - 1;
         for( i = 0; i < nlab; i++ ) {
            ll++;
            if( ll->priority == prio ) {

/* Find the closest label to this one on the high index side which has a
   higher priority. */
               llhi = NULL;
               for( j = i + 1; j < nlab; j++ ) {
                  if( list[ j ].priority > prio ) {
                     llhi = list + j;
                     break;
                  }
               }

/* If no higher priority neighbour was found on the high index side,
   use the nearest label with the current priority on the high index side. */
               if( !llhi ) {
                  for( j = i + 1; j < nlab; j++ ) {
                     if( list[ j ].priority == prio ) {
                        llhi = list + j;
                        break;
                     }
                  }
               }

/* Find the closest label to this one on the low index side which has a
   higher priority. */
               lllo = NULL;
               for( j = i - 1; j >= 0; j-- ) {
                  if( list[ j ].priority > prio ) {
                     lllo = list + j;
                     break;
                  }
               }

/* If no higher priority neighbour was found on the low index side,
   use the nearest label with the current priority on the low index side. */
               if( !lllo ) {
                  for( j = i - 1; j >= 0; j-- ) {
                     if( list[ j ].priority == prio ) {
                        lllo = list + j;
                        break;
                     }
                  }
               }

/* If we are not abbreviating, use the full text as the abbreviated text.*/
               if( !abb ) {
                  ll->atext = ll->text;

/* Otherwise, if only one of these two neighbouring labels was found, we
   abbreviate the current label by comparing it with the one found
   neighbouring label. If they are identical, we use the last field as
   the abbreviated text. */
               } else if( !lllo ) {
                  ll->atext = astAbbrev( frame, axis, fmt, llhi->text,
                                         ll->text );

               } else if( !llhi ) {
                  ll->atext = astAbbrev( frame, axis, fmt, lllo->text,
                                         ll->text );

/* If two neighbouring labels were found, we abbreviate the current label
   by comparing it with both neighbouring labels, and choosing the shorter
   abbreviation. */
               } else {
                  textlo = abb ? astAbbrev( frame, axis, fmt, lllo->text,
                                            ll->text ) : ll->text;
                  texthi = abb ? astAbbrev( frame, axis, fmt, llhi->text,
                                            ll->text ) : ll->text;

                  lolen = strlen( textlo );
                  hilen = strlen( texthi );
                  if( lolen > 0 && lolen < hilen ) {
                     ll->atext = textlo;
                  } else {
                     ll->atext = texthi;
                  }
               }

/* If the two fields are identical, the abbreviated text returned by
   astAbbrev will be a null string. In this case, find the start of the
   last field in the formatted value (using astAbbrev again), and use
   that as the abbreviated text. */
               if( !(ll->atext)[0] ) {
                  ll->atext = astAbbrev( frame, axis, fmt, NULL, ll->text );
               }
            }
         }
      }

/* Find the bounding box of the root label and add it to the list of bounding
   boxes. */
      nleft = 1;
      ll = list + root;
      olap = Overlap( this, -1, esc,
                      SplitValue( this, ll->atext, axis, &split, status ),
                      (float) ll->x, (float) ll->y, ll->just, (float) ll->upx,
                      (float) ll->upy, box, method, class, status );

/* Now look for labels which would overlap. First, check labels above the root
   label. Do not count overlaps where the two abbreviated labels have the same text. */
      ll = list + root;
      latext = ll->atext;
      for( i = root + 1; i < nlab; i++ ) {
         ll++;
         if( ll->priority >= 0 ) {
            if( strcmp( ll->atext, latext ) ) {
               if( Overlap( this, -1, esc,
                            SplitValue( this, ll->atext, axis, &split, status ),
                            (float) ll->x, (float) ll->y, ll->just,
                            (float) ll->upx, (float) ll->upy, box, method,
                            class, status ) ){
                  olap++;
               } else {
                  nleft++;
               }
            }
            latext = ll->atext;
         }
      }

/* Now check the labels below the root label. */
      ll = list + root;
      latext = ll->atext;
      for( i = root - 1; i >= 0; i-- ) {
         ll--;
         if( ll->priority >= 0 ) {
            if( strcmp( ll->atext, latext ) ) {
               if( Overlap( this, -1, esc,
                            SplitValue( this, ll->atext, axis, &split, status ),
                            (float) ll->x, (float) ll->y, ll->just,
                            (float) ll->upx, (float) ll->upy, box, method,
                            class, status ) ){
                  olap++;
               } else {
                  nleft++;
               }
            }
            latext = ll->atext;
         }
      }

/* If only one overlap was found, and this is the second axis, ignore it
   since it is probably caused by the crossing of the two axes. */
      if( axis == 1 && olap == 1 ) olap = 0;

/* If we are now only plotting every 3rd label, or if there are less than
   3 labels left, and there are still overlapping labels, then we must have
   a very odd axis (such as logarithmically spaced ticks on a linearly mapped
   axis). In this case, we will re-instate the orignal label priorities and
   then leave this loop so that we attempt to plot all labels. Also retain
   original priorities if the axis is mapped logarithmically onto the
   screen. */
      if( olap && ( jgap == 3 || nleft < 3 || astGetLogPlot( this, axis ) ) ){
         jgap = 0;
         odd = 1;
      } else {
         odd = 0;
      }

/* If any labels overlapped, re-instate the priority of all previously
   excluded labels (using the copy of the label's real priority stored in
   "saved_prio"), and then remove labels (by setting their priorities
   negative) to increase the gap between labels, and try again. */
      if( olap ) {
         jgap++;

         nexti = root + jgap;
         for( i = root + 1; i < nlab; i++ ) {
            if( i == nexti ) {
               nexti += jgap;
               list[ i ].priority = list[ i ].saved_prio;
            } else {
               list[ i ].priority = -1;
            }
         }

         nexti = root - jgap;
         for( i = root - 1; i >= 0; i-- ) {
            if( i == nexti ) {
               nexti -= jgap;
               list[ i ].priority = list[ i ].saved_prio;
            } else {
               list[ i ].priority = -1;
            }
         }

/* Reset the abbreviated text to be the full text. */
         for( i = 0; i < nlab - 1; i++ ) list[ i ].atext = list[ i ].text;

      }

/* Rest the list of bounding boxes to exclude the boxes added above. */
      Overlap( this, nbox, esc, NULL, 0.0, 0.0, NULL, 0.0, 0.0, box, method,
               class, status );
   }

/* We can now draw the abbreviated labels (ignoring rejected labels). */
   ll = list-1;
   for( i = 0; i < nlab; i++ ) {
      ll++;
      if( ll->priority >= 0 ) {

/* Check that this label does not overlap any labels drawn for previous
   axes (we know from the above processing that it will not overlap any
   other label on the current axis). */
         if( !Overlap( this, -1, esc,
                       SplitValue( this, ll->atext, axis, &split, status ),
                       (float) ll->x, (float) ll->y, ll->just, (float) ll->upx,
                       (float) ll->upy, box, method, class, status ) ) {

/* Draw the abbreviated label text, and get the bounds of the box containing
   the new label, splitting long formatted values (such as produced by
   TimeFrames) into two lines. */
            DrawText( this, 1, esc,
                      SplitValue( this, ll->atext, axis, &split, status ),
                      (float) ll->x, (float) ll->y, ll->just, (float) ll->upx,
                      (float) ll->upy, xbn, ybn, NULL, method, class, status );
         }
      }
   }
}

static void PolyCurve( AstPlot *this, int npoint, int ncoord, int indim,
                       const double *in, int *status ){
/*
*++
*  Name:
c     astPolyCurve
f     AST_POLYCURVE

*  Purpose:
*     Draw a series of connected geodesic curves.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astPolyCurve( AstPlot *this, int npoint, int ncoord, int indim,
c                        const double *in )
f     CALL AST_POLYCURVE( THIS, NPOINT, NCOORD, INDIM, IN, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
c     This function joins a series of points specified in the physical
c     coordinate system of a Plot by drawing a sequence of geodesic
c     curves.  It is equivalent to making repeated use of the astCurve
c     function (q.v.), except that astPolyCurve will generally be more
c     efficient when drawing many geodesic curves end-to-end. A
c     typical application of this might be in drawing contour lines.
f     This routine joins a series of points specified in the physical
f     coordinate system of a Plot by drawing a sequence of geodesic
f     curves.  It is equivalent to making repeated calls to the
f     AST_CURVE routine (q.v.), except that AST_POLYCURVE will
f     generally be more efficient when drawing many geodesic curves
f     end-to-end. A typical application of this might be in drawing
f     contour lines.
*
c     As with astCurve, full account is taken of the Mapping between
c     physical and graphical coordinate systems. This includes any
c     discontinuities and clipping established using astClip.
f     As with AST_CURVE, full account is taken of the Mapping between
f     physical and graphical coordinate systems. This includes any
f     discontinuities and clipping established using AST_CLIP.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     npoint
f     NPOINT = INTEGER (Given)
*        The number of points between which geodesic curves are to be drawn.
c     ncoord
f     NCOORD = INTEGER (Given)
*        The number of coordinates being supplied for each point (i.e.
*        the number of axes in the current Frame of the Plot, as given
*        by its Naxes attribute).
c     indim
f     INDIM = INTEGER (Given)
c        The number of elements along the second dimension of the "in"
f        The number of elements along the first dimension of the IN
*        array (which contains the input coordinates). This value is
*        required so that the coordinate values can be correctly
*        located if they do not entirely fill this array. The value
c        given should not be less than "npoint".
f        given should not be less than NPOINT.
c     in
f     IN( INDIM, NCOORD ) = DOUBLE PRECISION (Given)
c        The address of the first element in a 2-dimensional array of shape
c        "[ncoord][indim]" giving the
c        physical coordinates of the points which are to be joined in
c        sequence by geodesic curves. These should be stored such that
c        the value of coordinate number "coord" for point number
c        "point" is found in element "in[coord][point]".
f        A 2-dimensional array giving the physical coordinates of the
f        points which are to be joined in sequence by geodesic
f        curves. These should be stored such that the value of
f        coordinate number COORD for input point number POINT is found
f        in element IN(POINT,COORD).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - No curve is drawn on either side of any point which has any
*     coordinate equal to the value AST__BAD.
*     - An error results if the base Frame of the Plot is not
*     2-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*--
*/
/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   const double **in_ptr;  /* Pointer to array of data pointers */
   double *finish;         /* Pointer to array holding segment end position */
   double *start;          /* Pointer to array holding segment start position */
   double d[ CRV_NPNT ];   /* Offsets to evenly spaced points along curve */
   double tol;             /* Absolute tolerance value */
   double x[ CRV_NPNT ];   /* X coords at evenly spaced points along curve */
   double y[ CRV_NPNT ];   /* Y coords at evenly spaced points along curve */
   int coord;              /* Loop counter for coordinates */
   int i;                  /* Loop count */
   int naxes;              /* No. of Frame axes */
   int ok;                 /* Are all start and end coords good? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astPolyCurve";
   class = astGetClass( this );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Initialise the bounding box for primatives produced by this call. */
   if( !Boxp_freeze ) {
      Boxp_lbnd[ 0 ] = FLT_MAX;
      Boxp_lbnd[ 1 ] = FLT_MAX;
      Boxp_ubnd[ 0 ] = FLT_MIN;
      Boxp_ubnd[ 1 ] = FLT_MIN;
   }

/* Check the current Frame of the Plot has ncoord axes. */
   naxes = astGetNout( this );
   if( naxes != ncoord && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the current "
                "Frame of the supplied %s is invalid - this number should "
                "be %d (possible programming error).", status, method, class, naxes,
                class, ncoord );
   }

/* Check the array dimension argument. */
   if ( astOK && ( indim < npoint ) ) {
      astError( AST__DIMIN, "%s(%s): The array dimension value "
                "(%d) is invalid.", status, method, class, indim );
      astError( AST__DIMIN, "This should not be less than the number of "
                "points being drawn (%d).", status, npoint );
   }

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Allocate memory to hold the array of data pointers, the start position,
   and the end position. */
   if ( astOK ) {
      in_ptr = (const double **) astMalloc( sizeof( const double * ) *
                                            (size_t) ncoord );
      start = (double *) astMalloc( sizeof( double ) * (size_t) ncoord );
      finish = (double *) astMalloc( sizeof( double ) * (size_t) ncoord );

/* Set up externals used to communicate with the Map3 function...
   The number of axes in the physical coordinate system (i.e. the current
   Frame). */
      Map3_ncoord = ncoord;

/* A pointer to the Plot, the Current Frame, and and Mapping. */
      Map3_plot = this;
      Map3_frame = astGetFrame( this, AST__CURRENT );
      Map3_map = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Convert the tolerance from relative to absolute graphics coordinates. */
      tol = astGetTol( this )*astMAX( this->xhi - this->xlo,
                                      this->yhi - this->ylo );

/* Ensure the globals holding the scaling from graphics coords to equally
   scaled coords are available. */
      GScales( this, NULL, NULL, method, class, status );

/* Now set up the external variables used by the Crv and CrvLine function. */
      Crv_scerr = ( astGetLogPlot( this, 0 ) ||
                    astGetLogPlot( this, 1 ) ) ? 100.0 : 1.5;
      Crv_tol = tol;
      Crv_limit = 0.5*tol*tol;
      Crv_map = Map3;
      Crv_ink = 1;
      Crv_xlo = this->xlo;
      Crv_xhi = this->xhi;
      Crv_ylo = this->ylo;
      Crv_yhi = this->yhi;
      Crv_clip = astGetClip( this ) & 1;

/* Set up a list of points spread evenly over each curve segment. */
      for( i = 0; i < CRV_NPNT; i++ ){
        d[ i ] = ( (double) i)/( (double) CRV_NSEG );
      }

/* Initialise the data pointers to locate the coordinate data in
   the "in" array. */
      if ( astOK ) {
         for ( coord = 0; coord < ncoord; coord++ ) {
            in_ptr[ coord ] = in + coord * indim;
         }

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
         astGrfAttrs( this, AST__CURVE_ID, 1, GRF__LINE, method, class );

/* Loop round each curve segment. */
         for( i = 1 ; i < npoint; i++ ) {

/* Store the start position and check it for bad values. Increment the
   pointers to the next position on each axis, so that they refer to the
   finish point of the current curve segment. */
            ok = 1;
            for( coord = 0; coord < ncoord; coord++ ) {
               if( *( in_ptr[coord] ) == AST__BAD ){
                  ok = 0;
               } else {
                  start[ coord ] = *( in_ptr[coord] );
               }
               ( in_ptr[coord] )++;
            }

/* Store the end position and check it for bad values. Do not increment
   the axis pointers. This means that they will refer to the start position
   of the next curve segment on the next pass through this loop. */
            for( coord = 0; coord < ncoord; coord++ ) {
               if( *( in_ptr[coord] ) == AST__BAD ){
                  ok = 0;
               } else {
                  finish[ coord ] = *( in_ptr[coord] );
               }
            }

/* Pass on to the next curve segment if either the start or finish position
   was bad. */
            if( ok ) {

/* Set up the remaining externals used to communicate with the Map3
   function... */

/* The physical coordinates at the start of the curve. */
               Map3_origin = start;

/* The physical coordinates at the end of the curve. */
               Map3_end = finish;

/* The scale factor to convert "dist" values into physical offset values. */
               Map3_scale = astDistance( Map3_frame, start, finish );

/* Now set up the remaining external variables used by the Crv and CrvLine
   function. */
               Crv_ux0 = AST__BAD;
               Crv_out = 1;
               Crv_xbrk = Curve_data.xbrk;
               Crv_ybrk = Curve_data.ybrk;
               Crv_vxbrk = Curve_data.vxbrk;
               Crv_vybrk = Curve_data.vybrk;

/* Map the evenly spread distances between "start" and "finish" into graphics
   coordinates. */
               Map3( CRV_NPNT, d, x, y, method, class, status GLOBALS_NAME );

/* Use Crv and Map3 to draw the curve segment. */
               Crv( this, d, x, y, 0, NULL, NULL, method, class, status );

/* If no part of the curve could be drawn, set the number of breaks and the
   length of the drawn curve to zero. */
               if( Crv_out ) {
                  Crv_nbrk = 0;
                  Crv_len = 0.0F;

/* Otherwise, add an extra break to the returned structure at the position of
   the last point to be plotted. */
               } else {
                  Crv_nbrk++;
                  if( Crv_nbrk > AST__PLOT_CRV_MXBRK ){
                     astError( AST__CVBRK, "%s(%s): Number of breaks in curve "
                               "exceeds %d.", status, method, class, AST__PLOT_CRV_MXBRK );
                  } else {
                     *(Crv_xbrk++) = (float) Crv_xl;
                     *(Crv_ybrk++) = (float) Crv_yl;
                     *(Crv_vxbrk++) = (float) -Crv_vxl;
                     *(Crv_vybrk++) = (float) -Crv_vyl;
                  }
               }

/* Store extra information about the curve in the returned structure, and
   purge any zero length sections. */
               Curve_data.length = Crv_len;
               Curve_data.out = Crv_out;
               Curve_data.nbrk = Crv_nbrk;
               PurgeCdata( &Curve_data, status );
            }
         }

/* End the last poly line. */
         Opoly( this, status );

/* Tidy up the static data used by Map3. */
         Map3( 0, NULL, NULL, NULL, method, class, status GLOBALS_NAME );

/* Ensure all lines are flushed to the graphics system. */
         Fpoly( this, method, class, status );

/* Re-establish the original graphical attributes. */
         astGrfAttrs( this, AST__CURVE_ID, 0, GRF__LINE, method, class );
      }

/* Annul the Frame and Mapping. */
      Map3_frame = astAnnul( Map3_frame );
      Map3_map = astAnnul( Map3_map );

/* Free the memory used for the data pointers, and start and end positions. */
      in_ptr = (const double **) astFree( (void *) in_ptr );
      start = (double *) astFree( (void *) start );
      finish = (double *) astFree( (void *) finish );
   }
}

static int PopGat( AstPlot *this, float *rise, const char *method,
                   const char *class, int *status ) {
/*
*  Name:
*     PopGat

*  Purpose:
*     Pop current graphical attributes for text from a stack.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int PopGat( AstPlot *this, float *rise, const char *method,
*                 const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function restores the current graphical attributes for text
*     from the values on a stack. Current attributes are left unchanged if
*     the stack is empty.

*  Parameters:
*     this
*        Pointer to the Plot.
*     rise
*        Pointer to a location at which to return thhe height of the baseline
*        above the normal baseline, expressed as a percentage of the normal
*        character height.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Returns zero if the stack is empty, and 1 otherwise.

*/

/* Local Variables: */
   AstGat *gat;
   int result;

/* Initialise */
   result = 0;

/* Check inherited status */
   if( !astOK ) return result;

/* Check there is at least one AstGat structure on the stack. */
   if( this->ngat ) {

/* Decrement the number of entries in the stack, and get a pointer to the
   AstGat structure. Nullify the pointer on the stack. */
      gat = (this->gat)[ --(this->ngat) ];
      (this->gat)[ this->ngat ] = NULL;

/* Restore the values in the AstGat structure */
      *rise = gat->rise;
      GAttr( this, GRF__SIZE, gat->size, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__WIDTH, gat->width, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__COLOUR, gat->col, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__FONT, gat->font, NULL, GRF__TEXT, method, class, status );
      GAttr( this, GRF__STYLE, gat->style, NULL, GRF__TEXT, method, class, status );

/* Free the AstGat structure. */
      gat = astFree( gat );

/* Indicate success.*/
      result = 1;
   }

/* Return the result. */
   return result;

}

static void PurgeCdata( AstPlotCurveData *cdata, int *status ){
/*
*
*  Name:
*     AstPlotCurveData

*  Purpose:
*     Remove any zero length sections from the description of a curve.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void PurgeCdata( AstPlotCurveData *cdata )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function removes any zero length sections from the supplied
*     AstPlotCurveData struture, which describes a multi-section curve.

*  Parameters:
*     cdata
*        A pointer to the structure containing information about the
*        breaks in a curve.

*/

/* Local Variables: */
   int brk;                       /*Break index */
   int i;                       /*Break index */

/* Check the global error status. */
   if ( !astOK || !cdata ) return;

/* Loop round all breaks. */
   brk = 0;
   while( brk < cdata->nbrk ) {

/* If this break and the next one are co-incident, remove both breaks. */
      if( cdata->xbrk[ brk ] == cdata->xbrk[ brk + 1 ] &&
          cdata->ybrk[ brk ] == cdata->ybrk[ brk + 1 ] ) {

/* Shuffle down the higher elements of all the arrays in the curve data. */
         for( i = brk + 2; i < cdata->nbrk; i++ ){
            cdata->xbrk[ i - 2 ] = cdata->xbrk[ i ];
            cdata->ybrk[ i - 2 ] = cdata->ybrk[ i ];
            cdata->vxbrk[ i - 2 ] = cdata->vxbrk[ i ];
            cdata->vybrk[ i - 2 ] = cdata->vybrk[ i ];
         }

/*  Decrement the number of breaks in the curve data. */
         cdata->nbrk -= 2;

/* If the section is not zero length, move on to the next pair of breaks. */
      } else {
         brk += 2;
      }
   }
}

static void PushGat( AstPlot *this, float rise, const char *method,
                     const char *class, int *status ) {
/*
*  Name:
*     PushGat

*  Purpose:
*     Push current graphical attributes for text onto a stack.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void PushGat( AstPlot *this, float rise, const char *method,
*                   const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function stores the current graphical attributes for text
*     on a stack.

*  Parameters:
*     this
*        Pointer to the Plot.
*     rise
*        The height of the baseline above the normal baseline, expressed
*        as a percentage of the normal character height.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstGat *new_gat;

/* Check inherited status */
   if( !astOK ) return;

/* Allocate memory for a new AstGat structure to store the graphical
   attributes. */
   new_gat = astMalloc( sizeof( AstGat ) );
   if( astOK ) {

/* Store the height of the current baseline above the normal baseline,
   expressed as a percentage of a normal character height. */
      new_gat->rise = rise;

/* Store the current graphical attribute values. */
      GAttr( this, GRF__SIZE, AST__BAD, &(new_gat->size), GRF__TEXT, method, class, status );
      GAttr( this, GRF__WIDTH, AST__BAD, &(new_gat->width), GRF__TEXT, method, class, status );
      GAttr( this, GRF__FONT, AST__BAD, &(new_gat->font), GRF__TEXT, method, class, status );
      GAttr( this, GRF__STYLE, AST__BAD, &(new_gat->style), GRF__TEXT, method, class, status );
      GAttr( this, GRF__COLOUR, AST__BAD, &(new_gat->col), GRF__TEXT, method, class, status );

/* Increment the number of AstGat structures on the stack.*/
      this->ngat++;

/* Extend the array of AstGat pointers in the Plot structure so that there
   is room for the new one. */
      this->gat = (AstGat **) astGrow( this->gat, this->ngat, sizeof( AstGat * ) );
      if( astOK ) {

/* Store the new pointer. */
         (this->gat)[ this->ngat - 1 ] = new_gat;

      }
   }
}

static void RegionOutline( AstPlot *this, AstRegion *region, int *status ){
/*
*++
*  Name:
c     astRegionOutline
f     AST_RegionOutline

*  Purpose:
*     Draw the outline of an AST Region.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astRegionOutline( AstPlot *this, AstRegion *region )
f     CALL AST_REGIONOUTLINE( THIS, REGION, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
*     This function draws an outline around the supplied AST Region object.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     region
f     REGION = INTEGER (Given)
*        Pointer to the Region.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*--
*/
/* Local Variables: */
   AstFrameSet *fs;
   AstMapping *map;
   const char *class;
   const char *method;
   int ibase;
   int icurr;

/* Check the global error status. */
   if ( !astOK ) return;

/* Store the current method, and the class of the supplied object for use
   in error messages.*/
   method = "astRegionOutline";
   class = astGetClass( this );

/* Save the base Frame index within the Plot, since astConvert will
   change it. */
   ibase = astGetBase( this );

/* Get the FrameSet that converts from the current Frame of the Plot, to the
   Frame represented by the Region. Check a conversion was found. */
   fs = astConvert( this, region, " " );

/* Re-instate the original base Frame. */
   astSetBase( this, ibase );

/* Report an error if the Region could not be mapped into the current
   Frame of the Plot. */
   if( !fs ) {
      if( astOK ) {
         astError( AST__NOCNV, "%s(%s): Cannot find a mapping from the "
                   "%d-dimensional Plot coordinate system (%s) to the "
                   "%d-dimensional Region coordinate system (%s).", status,
                   method, class, astGetNout( this ), astGetTitle( this ),
                   astGetNout( region ), astGetTitle( region ) );
      }

/* If a transformation from Plot to Region was found... */
   } else {

/* Add the Region as a new Frame into the Plot, connecting it to the
   current Frame using the FrameSet found above. It becomes the new current
   Frame. First record the index of the original current Frame since
   astAddFrame will modify the FrameSet to use a different current Frame. */
      icurr = astGetCurrent( this );
      map = astGetMapping( fs, AST__BASE, AST__CURRENT );
      astAddFrame( this, icurr, map, region );

/* Draw the outline of the Region (now the current Frame in the Plot). */
      astBorder( this );

/* Tidy up by removing the Region (i.e. the current Frame) from the Plot and
   re-instating the original current Frame. */
      astRemoveFrame( this, AST__CURRENT );
      astSetCurrent( this, icurr );

/* Free resources. */
      map = astAnnul( map );
      fs = astAnnul( fs );
   }
}

static void RemoveFrame( AstFrameSet *this_fset, int iframe, int *status ) {
/*
*  Name:
*     RemoveFrame

*  Purpose:
*     Remove a Frame from a Plot.

*  Type:
*     Public virtual function.

*  Synopsis:
*     #include "plot.h"
*     void RemoveFrame( AstFrameSet *this_fset, int iframe, int *status )

*  Class Membership:
*     Plot member function (over-rides the astRemoveFrame public
*     method inherited from the FrameSet class).

*  Description:
*     This function removes a Frame from a Plot. All other Frames
*     in the Plot have their indices re-numbered from one (if
*     necessary), but are otherwise unchanged.
*
*     If the index of the clipping Frame is changed, the index value
*     stored in the Plot is updated. If the clipping Frame itself is
*     removed, all clipping information is removed from the Plot.

*  Parameters:
*     this_fset
*        Pointer to the FrameSet component of the Plot.
*     iframe
*        The index within the Plot of the Frame to be removed.
*        This value should lie in the range from 1 to the number of
*        Frames in the Plot (as given by its Nframe attribute).
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstPlot *this;          /* Pointer to Plot structure */
   int ifrm;               /* Validated frame index */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) this_fset;

/* Validate the frame index. */
   ifrm = astValidateFrameIndex( this_fset, iframe, "astRemoveFrame" );

/* Invoke the parent astRemoveFrame method to remove the Frame. */
   (*parent_removeframe)( this_fset, iframe, status );

/* If the index of the removed Frame is smaller than the clipping Frame
   index, then decrement the clipping Frame index so that the same Frame
   will be used in future. */
   if( astOK ){
      if( ifrm < this->clip_frame ){
         (this->clip_frame)--;

/* If the clipping fgrame itself has been removed, indicate that no
   clipping should nbow be performed. */
      } else if( ifrm == this->clip_frame ){
         astClip( this, AST__NOFRAME, NULL, NULL );
      }
   }
}

static void RightVector( AstPlot *this, float *ux, float *uy, float *rx,
                         float *ry, const char *method, const char *class, int *status ){
/*
*  Name:
*     RightVector

*  Purpose:
*     Return a vector in the direction of the base line of normal text.

*  Synopsis:
*     #include "plot.h"
*     void RightVector( AstPlot *this, float *ux, float *uy, float *rx,
*                       float *ry, const char *method, const char *class, int *status )

*  Description:
*     This function returns a vector which points from left to right along
*     the text baseline, taking account of any difference in the scales of
*     the x and y axes. It also scales the supplied up vector so that it has
*     a length equal to the height of normal text, and scales the returned
*     right vector to have the same length (on the screen) as the up vector.

*  Parameters:
*     this
*        The plot.
*     ux
*        Pointer to a float holding the x component of the up-vector for the
*        text, in graphics coords. Scaled on exit so that the up vector has
*        length equal to the height of normal text.
*     uy
*        Pointer to a float holding the y component of the up-vector for the
*        text, in graphics coords. Scaled on exit so that the up vector has
*        length equal to the height of normal text.
*     rx
*        Pointer to a double in which will be put the x component of a
*        vector parallel to the baseline of normal text.
*     ry
*        Pointer to a double in which will be put the y component of a
*        vector parallel to the baseline of normal text.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/


/* Local Variables: */
   float alpha;         /* Scale factor for X axis */
   float beta;          /* Scale factor for Y axis */
   float chv;
   float chh;
   float l;             /* Normalisation constant */
   float a;
   float b;
   float nl;		/* Character height in standard coordinates */

/* Check inherited status */
   if( !astOK ) return;

/* Find the scale factors for the two axes which scale graphics coordinates
   into a "standard" coordinate system in which: 1) the axes have equal scale
   in terms of (for instance) millimetres per unit distance, 2) X values
   increase from left to right, 3) Y values increase from bottom to top. */
   GScales( this, &alpha, &beta, method, class, status );

/* Convert the up-vector into "standard" system in which the axes have
   equal scales, and increase left-to-right, bottom-to-top. */
   *ux *= alpha;
   *uy *= beta;

/* Normalise this up-vector. */
   l = sqrt( (*ux)*(*ux) + (*uy)*(*uy) );
   if( l <= 0.0 ) {
     *ux = 0.0;
     *uy = 1.0;
   } else {
     *ux /= l;
     *uy /= l;
   }

/* Find the height in "standard" coordinates of "normal" text draw with the
   requested up-vector. */
   GQch( this, &chv, &chh, method, class, status );
   a = (*ux)/(chv*alpha);
   b = (*uy)/(chh*beta);
   nl = 1.0/sqrt( a*a + b*b );

/* Scale the up-vector so that is has length equal to the height of "normal"
   text with the specified up-vector. */
   *ux *= nl;
   *uy *= nl;

/* Get the vector along the base-line of the text, by rotating the
   up-vector by 90 degrees clockwise. */
   *rx = *uy;
   *ry = -*ux;

/* Convert both vectors back from standard coords to normal world coords */
   *ux /= alpha;
   *uy /= beta;
   *rx /= alpha;
   *ry /= beta;

}

static void SaveTick( AstPlot *this, int axis, double gx, double gy,
                      int major, int *status ){
/*
*  Name:
*     SaveTick

*  Purpose:
*     Save info about a drawn tick in the Plot structure.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void SaveTick( AstPlot *this, int axis, double gx, double gy,
*                    int major, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function stores the start position and type of each drawn
*     tick in the given Plot.

*  Parameters:
*     this
*        Pointer to the Plot.
*     axis
*        The zero-based axis index to which the tick refers. If a
*        negative value is specified then all information about drawn ticks
*        curently stored in the Plot is erased.
*     gx
*        The graphics X position at the start of the tick mark.
*     gy
*        The graphics Y position at the start of the tick mark.
*     major
*        Non-zero if the tick mark is a major tick.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int i;
   int *count;
   double *tickgx;
   double *tickgy;

/* Free the tick info in the supplied Plot if required. Do this before
   checking the error status. */
   if( axis < 0 ) {
      for( i = 0; i < 3; i++ ) {
         this->majtickgx[ i ] = astFree( this->majtickgx[ i ] );
         this->majtickgy[ i ] = astFree( this->majtickgy[ i ] );
         this->mintickgx[ i ] = astFree( this->mintickgx[ i ] );
         this->mintickgy[ i ] = astFree( this->mintickgy[ i ] );
         this->mintickcount[ i ] = 0;
         this->majtickcount[ i ] = 0;
      }
      return;
   }

/* Check the global error status. */
   if ( !astOK ) return;

/* Get pointers to the arrays to use, and ensure the arrays are big
   enough to hold the new tick. */
   if( major ) {
      count = this->majtickcount + axis;
      tickgx = this->majtickgx[ axis ];
      tickgy = this->majtickgy[ axis ];
   } else {
      count = this->mintickcount + axis;
      tickgx = this->mintickgx[ axis ];
      tickgy = this->mintickgy[ axis ];
   }

/* Ensure the arrays are big enough to hold the new tick. */
   i = *count;
   tickgx = astGrow( tickgx, i + 1, sizeof( double ) );
   tickgy = astGrow( tickgy, i + 1, sizeof( double ) );

/* If memory was allocated succesfully, store the new tick information in
   the expanded arrays. */
   if( astOK ) {
      tickgx[ i ] = gx;
      tickgy[ i ] = gy;
      *count = i + 1;

/* Store the potentially updated array pointers. */
      if( major ) {
         this->majtickgx[ axis ] = tickgx;
         this->majtickgy[ axis ] = tickgy;
      } else {
         this->mintickgx[ axis ] = tickgx;
         this->mintickgy[ axis ] = tickgy;
      }
   }
}

static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
/*
*  Name:
*     SetAttrib

*  Purpose:
*     Set an attribute value for a Plot.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void SetAttrib( AstObject *this, const char *setting, int *status )

*  Class Membership:
*     Plot member function (over-rides the astSetAttrib protected
*     method inherited from the FrameSet class).

*  Description:
*     This function assigns an attribute value for a Plot, the
*     attribute and its value being specified by means of a string of
*     the form:
*
*        "attribute= value "
*
*     Here, "attribute" specifies the attribute name and should be in
*     lower case with no white space present. The value to the right
*     of the "=" should be a suitable textual representation of the
*     value to be assigned and this will be interpreted according to
*     the attribute's data type.  White space surrounding the value is
*     only significant for string attributes.

*  Parameters:
*     this
*        Pointer to the Plot.
*     setting
*        Pointer to a null terminated string specifying the new attribute
*        value.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstPlot *this;                /* Pointer to the Plot structure */
   char label[21];               /* Graphics item label */
   const char *class;            /* Pointer to class string */
   double dval;                  /* Double attribute value */
   int axis;                     /* Index for the axis */
   int edge;                     /* Index of edge within list */
   int id1;                      /* Plot object id */
   int id2;                      /* Plot object id */
   int id;                       /* Plot object id */
   int ival;                     /* Int attribute value */
   int len;                      /* Length of setting string */
   int nax;                      /* Number of graphics frame axes */
   int nc;                       /* Number of characters read by astSscanf */
   int id3;                      /* Third genuine identifier */
   int nid;                      /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) this_object;

/* Get the number of base Frame axis (2 for a Plot, 3 for a Plot3D). */
   nax = astGetNin( this );

/* Obtain the length of the setting string. */
   len = (int) strlen( setting );

/* Test for each recognised attribute in turn, using "astSscanf" to parse
   the setting string and extract the attribute value (or an offset to
   it in the case of string values). In each case, use the value set
   in "nc" to check that the entire string was matched. Once a value
   has been obtained, use the appropriate method to set it. */

/* Tol. */
/* ---- */
   if ( nc = 0,
        ( 1 == astSscanf( setting, "tol= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      astSetTol( this, dval );

/* Grid. */
/* ----- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "grid= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetGrid( this, ival );

/* TickAll. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "tickall= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetTickAll( this, ival );

/* ForceExterior */
/* ------------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "forceexterior= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetForceExterior( this, ival );

/* Invisible. */
/* ---------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "invisible= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetInvisible( this, ival );

/* Border. */
/* ------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "border= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetBorder( this, ival );

/* ClipOp. */
/* ------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "clipop= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetClipOp( this, ival );

/* Clip. */
/* ----- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "clip= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetClip( this, ival );

/* Grf. */
/* ---- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "grf= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetGrf( this, ival );

/* DrawTitle. */
/* ---------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "drawtitle= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetDrawTitle( this, ival );

/* DrawAxes. */
/* --------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "drawaxes= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetDrawAxes( this, axis, ival );

/* DrawAxes(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "drawaxes(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetDrawAxes( this, axis - 1, ival );

/* Abbrev. */
/* ------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "abbrev= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetAbbrev( this, axis, ival );

/* Abbrev(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "abbrev(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetAbbrev( this, axis - 1, ival );

/* Escape. */
/* ------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "escape= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetEscape( this, ival );

/* Edge(axis). */
/* ----------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( setting, "edge(%d)= %n%*s %n", &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      edge = FullForm( "left right top bottom", setting + ival, setting,
                       "astSet", astGetClass( this ), status );
      if( edge == 0 ) {
         astSetEdge( this, axis - 1, LEFT );
      } else if( edge == 1 ) {
         astSetEdge( this, axis - 1, RIGHT );
      } else if( edge == 2 ) {
         astSetEdge( this, axis - 1, TOP );
      } else if( edge == 3 ) {
         astSetEdge( this, axis - 1, BOTTOM );
      }

/* LabelAt (axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "labelat(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetLabelAt( this, axis - 1, dval );

/* Centre(axis). */
/* ------------ */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "centre(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetCentre( this, axis - 1, dval );

/* Gap. */
/* ---- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "gap= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetGap( this, axis, dval );

/* Gap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "gap(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetGap( this, axis - 1, dval );

/* LogGap. */
/* ---- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "loggap= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetLogGap( this, axis, dval );

/* LogGap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "loggap(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetLogGap( this, axis - 1, dval );

/* NumLabGap. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "numlabgap= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetNumLabGap( this, axis, dval );

/* NumLabGap(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "numlabgap(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetNumLabGap( this, axis - 1, dval );

/* TextLabGap. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "textlabgap= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetTextLabGap( this, axis, dval );

/* TextLabGap(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "textlabgap(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetTextLabGap( this, axis - 1, dval );

/* LabelUp. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "labelup= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetLabelUp( this, axis, ival );

/* LabelUp(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "labelup(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetLabelUp( this, axis - 1, ival );

/* LogPlot. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "logplot= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetLogPlot( this, axis, ival );

/* LogPlot(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "logplot(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetLogPlot( this, axis - 1, ival );

/* LogTicks. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "logticks= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetLogTicks( this, axis, ival );

/* LogTicks(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "logticks(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetLogTicks( this, axis - 1, ival );

/* LogLabel. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "loglabel= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetLogLabel( this, axis, ival );

/* LogLabel(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "loglabel(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetLogLabel( this, axis - 1, ival );

/* NumLab. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "numlab= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetNumLab( this, axis, ival );

/* NumLab(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "numlab(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetNumLab( this, axis - 1, ival );

/* MinTick. */
/* -------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "mintick= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetMinTick( this, axis, ival );

/* MinTick(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "mintick(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetMinTick( this, axis - 1, ival );

/* TextLab. */
/* ---------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "textlab= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetTextLab( this, axis, ival );

/* TextLab(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "textlab(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetTextLab( this, axis - 1, ival );

/* LabelUnits. */
/* --------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "labelunits= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetLabelUnits( this, axis, ival );

/* LabelUnits(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "labelunits(%d)= %d %n",
                              &axis, &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetLabelUnits( this, axis - 1, ival );

/* Style. */
/* ------ */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "style= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( id = 0; id < AST__NPID; id++ ) astSetStyle( this, id, ival );

/* Style(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "style(%20[^()])= %d %n",
                              label, &ival, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, "Style", "astSet", class, status ),
                    nax, &id1, &id2, &id3, status );
      astSetStyle( this, id1, ival );
      if( nid > 1 ) astSetStyle( this, id2, ival );
      if( nid > 2 ) astSetStyle( this, id3, ival );

/* Font. */
/* ----- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "font= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( id = 0; id < AST__NPID; id++ ) astSetFont( this, id, ival );

/* Font(label). */
/* ------------ */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "font(%20[^()])= %d %n",
                              label, &ival, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, "Font", "astSet", class, status ),
                    nax, &id1, &id2, &id3, status );
      astSetFont( this, id1, ival );
      if( nid > 1 ) astSetFont( this, id2, ival );
      if( nid > 2 ) astSetFont( this, id3, ival );

/* Colour. */
/* ------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "colour= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( id = 0; id < AST__NPID; id++ ) astSetColour( this, id, ival );

/* Colour(label). */
/* -------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "colour(%20[^()])= %d %n",
                              label, &ival, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, "Colour", "astSet", class, status ),
                    nax, &id1, &id2, &id3, status );
      astSetColour( this, id1, ival );
      if( nid > 1 ) astSetColour( this, id2, ival );
      if( nid > 2 ) astSetColour( this, id3, ival );

/* Color. */
/* ------ */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "color= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      for( id = 0; id < AST__NPID; id++ ) astSetColour( this, id, ival );

/* Color(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "color(%20[^()])= %d %n",
                              label, &ival, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, "Color", "astSet", class, status ),
                    nax, &id1, &id2, &id3, status );
      astSetColour( this, id1, ival );
      if( nid > 1 ) astSetColour( this, id2, ival );
      if( nid > 2 ) astSetColour( this, id3, ival );

/* Width. */
/* ------ */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "width= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( id = 0; id < AST__NPID; id++ ) astSetWidth( this, id, dval );

/* Width(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "width(%20[^()])= %lg %n",
                              label, &dval, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, "Width", "astSet", class, status ),
                    nax, &id1, &id2, &id3, status );
      astSetWidth( this, id1, dval );
      if( nid > 1 ) astSetWidth( this, id2, dval );
      if( nid > 2 ) astSetWidth( this, id3, dval );

/* Size. */
/* ----- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "size= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( id = 0; id < AST__NPID; id++ ) astSetSize( this, id, dval );

/* Size(label). */
/* ------------ */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "size(%20[^()])= %lg %n",
                              label, &dval, &nc ) )
               && ( nc >= len ) ) {
      class =  astGetClass( this );

      nid = IdFind( FullForm( GrfLabels, label, "Size", "astSet", class, status ),
                    nax, &id1, &id2, &id3, status );
      astSetSize( this, id1, dval );
      if( nid > 1 ) astSetSize( this, id2, dval );
      if( nid > 2 ) astSetSize( this, id3, dval );

/* TitleGap. */
/* ----------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "titlegap= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      astSetTitleGap( this, dval );

/* MajTickLen. */
/* ----------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "majticklen= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetMajTickLen( this, axis, dval );

/* MajTickLen(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "majticklen(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetMajTickLen( this, axis - 1, dval );

/* MinTickLen. */
/* ----------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "minticklen= %lg %n", &dval, &nc ) )
        && ( nc >= len ) ) {
      for( axis = 0; axis < nax; axis++ ) astSetMinTickLen( this, axis, dval );

/* MinTickLen(axis). */
/* ----------------- */
   } else if ( nc = 0,
               ( 2 == astSscanf( setting, "minticklen(%d)= %lg %n",
                              &axis, &dval, &nc ) )
               && ( nc >= len ) ) {
      astSetMinTickLen( this, axis - 1, dval );

/* Labelling. */
/* -------- */
   } else if ( nc = 0,
               ( 0 == astSscanf( setting, "labelling= %n%*s %n", &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetLabelling( this, FullForm( "exterior interior",
                                        setting + ival, setting,
                                        "astSet", astGetClass( this ), status )
                      );

/* TextGapType. */
/* ------------ */
   } else if ( nc = 0,
               ( 0 == astSscanf( setting, "textgaptype= %n%*s %n", &ival, &nc ) )
               && ( nc >= len ) ) {
      astSetTextGapType( this, FullForm( "box plot", setting + ival, setting,
                                        "astSet", astGetClass( this ), status )
                      );

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_setattrib)( this_object, setting, status );
   }

/* Undefine macros local to this function. */
#undef MATCH
}

static void SetLogPlot( AstPlot *this, int axis, int ival, int *status ){
/*
*
*  Name:
*     SetLogPlot

*  Purpose:
*     Set a new value for a LogPlot attribute

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void SetLogPlot( AstPlot *this, int axis, int ival, int *status )

*  Class Membership:
*     Plot member function

*  Description:
*     Assigns a new value to the LogPlot attribute of the specified axis,
*     and also re-maps the base Frame of the Plot if necessary.

*  Parameters:
*     this
*        The Plot.
*     axis
*        Zero based axis index.
*     ival
*        The new value for the ogPlot attribute.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int oldval;              /* Original attribute value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Validate the axis index. */
   if( axis < 0 || axis >= 2 ){
      astError( AST__AXIIN, "astSetLogPlot(%s): Index (%d) is invalid for "
                "attribute LogPlot - it should be in the range 1 to 2.", status,
                astGetClass( this ), axis + 1 );

/* If the axis index is OK, store the original attribute value. We use
   astGetLogPlot to get the value rather than directly accessing
   "this->logplot" in order to get the any default value in the case of
   no value having been set. */
   } else {
      oldval = astGetLogPlot( this, axis );

/* If the current attribute value will change, attempt to re-map the plot
   axis. If the attempt succeeds, toggle the current attribute value. */
      if( ( ival != 0 ) != ( oldval != 0 ) ){
         if( ToggleLogLin( this, axis, oldval, "astSetLogPlot", status ) ){
            this->logplot[ axis ] = ( !oldval );
         }

/* If the current attribute value will not change, just store the supplied
   value (this is not redundant because it may cause a previously defaulted
   value to become an explicitly set value ). */
      } else {
         this->logplot[ axis ] = oldval;
      }
   }
}

static void SetTickValues( AstPlot *this, int axis, int nmajor, double *major,
                           int nminor, double *minor, int *status ){
/*
*+
*  Name:
*     astSetTickValues

*  Purpose:
*     Store the tick mark values to use for a given Plot axis.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "plot.h"
*     void astSetTickValues( AstPlot *this, int axis, int nmajor,
*                            double *major, int nminor, double *minor )

*  Class Membership:
*     Plot method.

*  Description:
*     This function stores a set of tick mark values that should be used by
*     subsequent calls to astGrid.

*  Parameters:
*     this
*        Pointer to a Plot.
*     axis
*        The zero-based index of the axis for which tick marks values
*        have been supplied.
*     nmajor
*        The number of major tick mark values. If zero is supplied then
*        the other parameters are ignored, and subsequent calls to
*        astGrid will itself determine the tick values to be used.
*     major
*        Pointer to an array holding "nmajor" values for axis "axis" in
*        the current Frame of the suppled Plot. Major tick marks will be
*        drawn at these values.
*     nminor
*        The number of minor tick mark values.
*     minor
*        Pointer to an array holding "nminor" values for axis "axis" in
*        the current Frame of the suppled Plot. Minor tick marks will be
*        drawn at these values.

*-
*/

/* Check the global status. */
   if( !astOK ) return;

/* Report an error if the supplied axis value is incorrect. */
   if( axis < 0 || axis >= astGetNin( this ) ) {
      astError( AST__INTER, "astSetTickValues(Plot): Supplied \"axis\" "
                "value is %d - should in the range 0 to %d (internal AST "
                "programming error).", status, axis, astGetNin( this ) - 1 );

/* Otherwise store or clear the values. */
   } else if( nmajor > 0 ){
      this->nmajtickval[ axis ] = nmajor;
      this->majtickval[ axis ] = astStore( this->majtickval[ axis ], major,
                                           sizeof( double )*nmajor );
      this->nmintickval[ axis ] = nminor;
      this->mintickval[ axis ] = astStore( this->mintickval[ axis ], minor,
                                           sizeof( double )*nminor );

/* Sort them into increasing order. */
      qsort( (void *) this->majtickval[ axis ], (size_t) nmajor,
             sizeof(double), Compared );

      qsort( (void *) this->mintickval[ axis ], (size_t) nminor,
             sizeof(double), Compared );

   } else {
      this->nmajtickval[ axis ] = 0;
      this->majtickval[ axis ] = astFree( this->majtickval[ axis ] );
      this->nmintickval[ axis ] = 0;
      this->mintickval[ axis ] = astFree( this->mintickval[ axis ] );
   }
}

const char *astStripEscapes_( const char *text, int *status ) {
/*
*++
*  Name:
c     astStripEscapes
f     AST_STRIPESCAPES

*  Purpose:
*     Remove AST escape sequences from a string.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     const char *astStripEscapes( const char *text )
f     RESULT = AST_STRIPESCAPES( TEXT )

*  Description:
*     This function removes AST escape sequences from a supplied string,
*     returning the resulting text as the function value. The behaviour
*     of this function can be controlled by invoking the
c     astEscapes function,
f     AST_ESCAPES routine,
*     which can be used to supress or enable the removal of escape
*     sequences by this function.
*
*     AST escape sequences are used by the Plot class to modify the
*     appearance and position of sub-strings within a plotted text string.
*     See the "Escape" attribute for further information.

*  Parameters:
c     text
c        Pointer to the string to be checked.
f     TEXT
f        The string to be checked.

*  Returned Value:
c     astStripEscapes()
f     AST_STRIPESCAPES = CHARACTER
c        Pointer to the modified string. If no escape sequences were found
c        in the supplied string, then a copy of the supplied pointer is
c        returned. Otherwise, the pointer will point to a static buffer
c        holding the modified text. This text will be over-written by
c        subsequent invocations of this function. If the astEscapes function
f        The modified string. If the AST_ESCAPES routine
*        has been called indicating that escape sequences should not be
*        stripped, then the supplied string is returned without change.

*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS
   const char *a;
   char *b;
   int nc;
   int ncc;
   int type;
   int value;
   const char *result;

/* Initialise */
   result= text;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Check inherited status and supplied pointer. Also return if the
   string contains no escape sequences or if stripping of escapes has
   been supressed. */
   if( !astOK || astEscapes( -1 ) || !text || !HasEscapes( text, status ) ) return result;

/* Initialise a pointer to the next character to be read from the
   supplied string. */
   a = text;

/* Initialise a pointer to the next character to be written to the
   returned string. */
   b = stripescapes_buff;

/* Note the available space left in the buffer. */
   ncc = AST__PLOT_STRIPESCAPES_BUFF_LEN;

/* Loop until all the string has been read, or the buffer is full. */
   while( *a && ncc > 0 ){

/* If the remaining string starts with an escape sequence, increment the
   read point by the length of the escape sequence, but leave the write
   pointer where it is. */
      if( astFindEscape( a, &type, &value, &nc ) ) {
         a += nc;

/* If the remaining string does not start with an escape sequence, copy
   the following text from the read position to the write position. */
      } else {
         if( nc > ncc ) nc = ncc;
         memcpy( b, a, sizeof( char )*nc );
         a += nc;
         b += nc;
         ncc -= nc;
      }
   }

/* Terminate the returned string. */
   *b = 0;

/* Return the result.*/
   return stripescapes_buff;
}

static int swapEdges( AstPlot *this, TickInfo **grid, AstPlotCurveData **cdata, int *status ) {
/*
*  Name:
*     swapEdges

*  Purpose:
*     Determine if edges for text labels should be swapped.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int swapEdges( AstPlot *this, TickInfo **grid, AstPlotCurveData **cdata, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     or not it is necessary to swap the Edges(0) and Edges(1) attributes
*     in order to place textual labels on appropriate edges. This should
*     only be used if the attributes have not explicitly been set, and if
*     interior labelling is being used. The sides are determines by
*     looking at the bounding box of tick marks on axis 0, in graphics
*     coordinates. The returned value causes the label for axis 0 to be
*     placed on the edge parallel to the longest side of this bounding box.
*     The label for axis 1 is placed parallel to the shortest side of this
*     bounding box.

*  Parameters:
*     this
*        A pointer to the Plot.
*     grid
*        A pointer to an array of two TickInfo pointers (one for each axis),
*        each pointing to a TickInfo structure holding information about
*        tick marks on the axis. See function GridLines.
*     cdata
*        A pointer to an array of two AstPlotCurveData pointers (one for each axis),
*        each pointing to an array of AstPlotCurveData structure (one for each
*        major tick value on the axis), holding information about breaks
*        in the curves drawn to mark the major tick values. See function
*        DrawGrid.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One if the edges should be swapped, otherwise zero.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstPlotCurveData *cdt; /* Pointer to the AstPlotCurveData for the next tick */
   TickInfo *info;        /* Pointer to the TickInfo for the current axis */
   float xmax;            /* Max graphics X value */
   float xmin;            /* Min graphics X value */
   float ymax;            /* Max graphics Y value */
   float ymin;            /* Min graphics Y value */
   int oldedge;           /* The original edge for axis 0 */
   int result;            /* Swap edges? */
   int tick;              /* Tick index */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the structure containing information describing the
   positions of the major tick marks along axis 0. */
   info = grid[ 0 ];

/* Get a pointer to the structure containing information describing
   the breaks in the curve which is parallel to axis 1 and passes
   through the first major tick mark on axis 0. */
   cdt = cdata[ 0 ];

/* Initialise the graphiocs X and Y bounds of the area covered by the
   axis. */
   xmax = -1.0E10;
   xmin = 1.0E10;
   ymax = -1.0E10;
   ymin = 1.0E10;

/* Loop round each of the major tick marks on axis 0. */
   for( tick = 0; cdt && info && tick < info->nmajor; tick++ ){

/* Update the max and min graphics X and Y coords covered by the axis. */
      if( cdt->nbrk > 0 ) {
         xmax = astMAX( xmax, cdt->xbrk[0] );
         xmin = astMIN( xmin, cdt->xbrk[0] );
         ymax = astMAX( ymax, cdt->ybrk[0] );
         ymin = astMIN( ymin, cdt->ybrk[0] );
      }

/* Get a pointer to the curve through the next major tick mark. */
      cdt++;

   }

/* See which edge axis 0 would normally be labelled on. */
   oldedge = astGetEdge( this, 0 );

/* If the X range is larger than the Y range, the textual label should be
   placed on the bottom edge. If required, indicate that the edges must
   be swapped to achieve this. */
   if( xmax - xmin > ymax - ymin ) {
      if( oldedge == 0 || oldedge == 2 ) result = 1;

/* If the X range is smaller  than the Y range, the textual label should be
   placed on the left edge. If required, indicate that the edges must
   be swapped to achieve this. */
   } else {
      if( oldedge == 1 || oldedge == 3 ) result = 1;
   }

   return result;
}

static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     TestAttrib

*  Purpose:
*     Test if a specified attribute value is set for a Plot.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TestAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     Plot member function (over-rides the astTestAttrib protected
*     method inherited from the FrameSet class).

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     a value has been set for one of a Plot's attributes.

*  Parameters:
*     this
*        Pointer to the Plot.
*     attrib
*        Pointer to a null terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One if a value has been set, otherwise zero.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstPlot *this;                /* Pointer to the Plot structure */
   char label[21];               /* Graphics item label */
   int axis;                     /* Axis number */
   int len;                      /* Length of attrib string */
   int nc;                       /* No. characters read by astSscanf */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) this_object;

/* Obtain the length of the attrib string. */
   len = strlen( attrib );

/* Check the attribute name and test the appropriate attribute. */

/* Tol. */
/* ---- */
   if ( !strcmp( attrib, "tol" ) ) {
      result = astTestTol( this );

/* Edge(axis). */
/* ----------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "edge(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestEdge( this, axis - 1 );

/* Grid. */
/* ----- */
   } else if ( !strcmp( attrib, "grid" ) ) {
      result = astTestGrid( this );

/* TickAll. */
/* -------- */
   } else if ( !strcmp( attrib, "tickall" ) ) {
      result = astTestTickAll( this );

/* ForceExterior */
/* ------------- */
   } else if ( !strcmp( attrib, "forceexterior" ) ) {
      result = astTestForceExterior( this );

/* Invisible. */
/* ---------- */
   } else if ( !strcmp( attrib, "invisible" ) ) {
      result = astTestInvisible( this );

/* Border. */
/* ------- */
   } else if ( !strcmp( attrib, "border" ) ) {
      result = astTestBorder( this );

/* ClipOp. */
/* ------- */
   } else if ( !strcmp( attrib, "clipop" ) ) {
      result = astTestClipOp( this );

/* Clip. */
/* ----- */
   } else if ( !strcmp( attrib, "clip" ) ) {
      result = astTestClip( this );

/* Grf. */
/* ---- */
   } else if ( !strcmp( attrib, "grf" ) ) {
      result = astTestGrf( this );

/* DrawTitle. */
/* ---------- */
   } else if ( !strcmp( attrib, "drawtitle" ) ) {
      result = astTestDrawTitle( this );

/* DrawAxes. */
/* --------- */
   } else if ( !strcmp( attrib, "drawaxes" ) ) {
      result = astTestDrawAxes( this, 0 );

/* DrawAxes(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "drawaxes(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestDrawAxes( this, axis - 1 );

/* Abbrev. */
/* --------- */
   } else if ( !strcmp( attrib, "abbrev" ) ) {
      result = astTestAbbrev( this, 0 );

/* Abbrev(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "abbrev(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestAbbrev( this, axis - 1 );

/* Escape. */
/* ------- */
   } else if ( !strcmp( attrib, "escape" ) ) {
      result = astTestEscape( this );

/* Gap. */
/* ---- */
   } else if ( !strcmp( attrib, "gap" ) ) {
      result = astTestGap( this, 0 );

/* Gap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "gap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestGap( this, axis - 1 );

/* LabelAt(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelat(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLabelAt( this, axis - 1 );

/* LogGap. */
/* ---- */
   } else if ( !strcmp( attrib, "loggap" ) ) {
      result = astTestLogGap( this, 0 );

/* LogGap(axis). */
/* ---------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "loggap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLogGap( this, axis - 1 );

/* NumLabGap. */
/* --------- */
   } else if ( !strcmp( attrib, "numlabgap" ) ) {
      result = astTestNumLabGap( this, 0 );

/* NumLabGap(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "numlabgap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestNumLabGap( this, axis - 1 );

/* TextLabGap. */
/* --------- */
   } else if ( !strcmp( attrib, "textlabgap" ) ) {
      result = astTestTextLabGap( this, 0 );

/* TextLabGap(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "textlabgap(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestTextLabGap( this, axis - 1 );

/* LabelUp. */
/* -------- */
   } else if ( !strcmp( attrib, "labelup" ) ) {
      result = astTestLabelUp( this, 0 );

/* LabelUp(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelup(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLabelUp( this, axis - 1 );

/* LogPlot. */
/* -------- */
   } else if ( !strcmp( attrib, "logplot" ) ) {
      result = astTestLogPlot( this, 0 );

/* LogPlot(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "logplot(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLogPlot( this, axis - 1 );

/* LogTicks. */
/* -------- */
   } else if ( !strcmp( attrib, "logticks" ) ) {
      result = astTestLogTicks( this, 0 );

/* LogTicks(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "logticks(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLogTicks( this, axis - 1 );

/* LogLabel. */
/* -------- */
   } else if ( !strcmp( attrib, "loglabel" ) ) {
      result = astTestLogLabel( this, 0 );

/* LogLabel(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "loglabel(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLogLabel( this, axis - 1 );

/* NumLab. */
/* -------- */
   } else if ( !strcmp( attrib, "numlab" ) ) {
      result = astTestNumLab( this, 0 );

/* NumLab(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "numlab(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestNumLab( this, axis - 1 );

/* MinTick. */
/* -------- */
   } else if ( !strcmp( attrib, "mintick" ) ) {
      result = astTestMinTick( this, 0 );

/* MinTick(axis). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "mintick(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestMinTick( this, axis - 1 );

/* TextLab. */
/* ---------- */
   } else if ( !strcmp( attrib, "textlab" ) ) {
      result = astTestTextLab( this, 0 );

/* TextLab(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "textlab(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestTextLab( this, axis - 1 );

/* LabelUnits. */
/* --------- */
   } else if ( !strcmp( attrib, "labelunits" ) ) {
      result = astTestLabelUnits( this, 0 );

/* LabelUnits(axis). */
/* --------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "labelunits(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestLabelUnits( this, axis - 1 );

/* Style. */
/* ------ */
   } else if ( !strcmp( attrib, "style" ) ) {
      result = TestUseStyle( this, AST__BORDER_ID, status );

/* Style(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "style(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      result = TestUseStyle( this, FullForm( GrfLabels, label, attrib, "astTest", astGetClass( this ), status ), status );

/* Font. */
/* ----- */
   } else if ( !strcmp( attrib, "font" ) ) {
      result = TestUseFont( this, AST__TEXTLABS_ID, status );

/* Font(label). */
/* ------------ */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "font(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      result = TestUseFont( this, FullForm( GrfLabels, label, attrib, "astTest", astGetClass( this ), status ), status );

/* Colour. */
/* ------- */
   } else if ( !strcmp( attrib, "colour" ) ) {
      result = TestUseColour( this, AST__TEXTLABS_ID, status );

/* Color. */
/* ------- */
   } else if ( !strcmp( attrib, "color" ) ) {
      result = TestUseColour( this, AST__TEXTLABS_ID, status );

/* Colour(label). */
/* -------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "colour(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      result = TestUseColour( this, FullForm( GrfLabels, label, attrib, "astTest", astGetClass( this ), status ), status );

/* Color(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "color(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      result = TestUseColour( this, FullForm( GrfLabels, label, attrib, "astTest", astGetClass( this ), status ), status );

/* Width. */
/* ------ */
   } else if ( !strcmp( attrib, "width" ) ) {
      result = TestUseWidth( this, AST__BORDER_ID, status );

/* Width(label). */
/* ------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "width(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      result = TestUseWidth( this, FullForm( GrfLabels, label, attrib, "astTest", astGetClass( this ), status ), status );

/* Size. */
/* ----- */
   } else if ( !strcmp( attrib, "size" ) ) {
      result = TestUseSize( this, AST__TEXTLABS_ID, status );

/* Size(label). */
/* ------------ */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "size(%20[^()])%n", label, &nc ) )
               && ( nc >= len ) ) {
      result = TestUseSize( this, FullForm( GrfLabels, label, attrib, "astTest", astGetClass( this ), status ), status );

/* TitleGap. */
/* --------- */
   } else if ( !strcmp( attrib, "titlegap" ) ) {
      result = astTestTitleGap( this );

/* MajTickLen. */
/* ----------- */
   } else if ( !strcmp( attrib, "majticklen" ) ) {
      result = astTestMajTickLen( this, 0 );

/* MajTickLen(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "majticklen(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestMajTickLen( this, axis - 1 );

/* MinTickLen. */
/* ----------- */
   } else if ( !strcmp( attrib, "minticklen" ) ) {
      result = astTestMinTickLen( this, 0 );

/* MinTickLen(axis). */
/* ---------------- */
   } else if ( nc = 0,
               ( 1 == astSscanf( attrib, "minticklen(%d)%n", &axis, &nc ) )
               && ( nc >= len ) ) {
      result = astTestMinTickLen( this, axis - 1 );

/* Labelling. */
/* -------- */
   } else if ( !strcmp( attrib, "labelling" ) ) {
      result = astTestLabelling( this );

/* TextGapType. */
/* ------------ */
   } else if ( !strcmp( attrib, "textgaptype" ) ) {
      result = astTestTextGapType( this );

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_testattrib)( this_object, attrib, status );
   }

/* Return the result, */
   return result;
}

static void Text( AstPlot *this, const char *text, const double pos[],
                  const float up[], const char *just, int *status ){
/*
*++
*  Name:
c     astText
f     AST_TEXT

*  Purpose:
*     Draw a text string for a Plot.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "plot.h"
c     void astText( AstPlot *this, const char *text, const double pos[],
c                   const float up[], const char *just )
f     CALL AST_TEXT( THIS, TEXT, POS, UP, JUST, STATUS )

*  Class Membership:
*     Plot method.

*  Description:
*     This function draws a string of text at a position specified in
*     the physical coordinate system of a Plot. The physical position
*     is transformed into graphical coordinates to determine where the
*     text should appear within the plotting area.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the Plot.
c     text
f     TEXT = CHARACTER * ( * ) (Given)
c        Pointer to a null-terminated character string containing the
f        A character string containing the
*        text to be drawn. Trailing white space is ignored.
c     pos
f     POS( * ) = DOUBLE PRECISION (Given)
*        An array, with one element for each axis of the Plot, giving
*        the physical coordinates of the point where the reference
*        position of the text string is to be placed.
c     up
f     UP( * ) = REAL (Given)
*        An array holding the components of a vector in the "up"
*        direction of the text (in graphical coordinates). For
c        example, to get horizontal text, the vector {0.0f,1.0f} should
f        example, to get horizontal text, the vector [0.0,1.0] should
*        be supplied. For a basic Plot, 2 values should be supplied. For
*        a Plot3D, 3 values should be supplied, and the actual up vector
*        used is the projection of the supplied up vector onto the text plane
*        specified by the current value of the Plot3D's Norm attribute.
c     just
f     JUST = CHARACTER * ( * ) (Given)
c        Pointer to a null-terminated character string identifying the
f        A character string identifying the
*        reference point for the text being drawn. The first character in
*        this string identifies the reference position in the "up" direction
*        and may be "B" (baseline), "C" (centre), "T" (top) or "M" (bottom).
*        The second character identifies the side-to-side reference position
*        and may be "L" (left), "C" (centre) or "R" (right ). The string is
*        case-insensitive, and only the first two characters are significant.
*
*        For example, a value of "BL" means that the left end of the
*        baseline of the original (un-rotated) text is to be drawn at the
c        position given by "pos".
f        position given by POS.

f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - The Plot3D class currently does not interpret graphical escape
*     sequences contained within text displayed using this method.
*     - Text is not drawn at positions which have any coordinate equal
*     to the value AST__BAD (or where the transformation into
*     graphical coordinates yields coordinates containing the value
*     AST__BAD).
c     - If the plotting position is clipped (see astClip), then no
f     - If the plotting position is clipped (see AST_CLIP), then no
*     text is drawn.
*     - An error results if the base Frame of the Plot is not
*     2-dimensional or (for a Plot3D) 3-dimensional.
*     - An error also results if the transformation between the
*     current and base Frames of the Plot is not defined (i.e. the
*     Plot's TranInverse attribute is zero).
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   AstMapping *mapping;    /* Pointer to graphics->physical mapping */
   AstPointSet *pset1;     /* PointSet holding physical positions */
   AstPointSet *pset2;     /* PointSet holding graphics positions */
   const char *class;      /* Object class */
   const char *method;     /* Current method */
   const double **ptr1;    /* Pointer to physical positions */
   char ljust[3];          /* Upper case copy of "just" */
   char *ltext;            /* Local copy of "text" excluding trailing spaces */
   double **ptr2;          /* Pointer to graphics positions */
   float xbn[ 4 ];         /* X coords of text bounding box. */
   float ybn[ 4 ];         /* Y coord of text bounding box. */
   int axis;               /* Axis index */
   int escs;               /* Original astEscapes value */
   int naxes;              /* No. of axes in the base Frame */
   int ncoord;             /* No. of axes in the current Frame */
   int ulen;               /* Length of "text" excluding trailing spaces */

/* Check the global error status. */
   if ( !astOK || !text ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Store the current method and class for inclusion in error messages
   generated by lower level functions. */
   method = "astText";
   class = astClass( this );

/* Check the base Frame of the Plot is 2-D. */
   naxes = astGetNin( this );
   if( naxes != 2 && astOK ){
      astError( AST__NAXIN, "%s(%s): Number of axes (%d) in the base "
                "Frame of the supplied %s is invalid - this number should "
                "be 2.", status, method, class, naxes, class );
   }

/* Ensure AST functions included graphical escape sequences in any
   returned text strings. */
   escs = astEscapes( 1 );

/* Initialise the bounding box for primatives produced by this call. */
   if( !Boxp_freeze ) {
      Boxp_lbnd[ 0 ] = FLT_MAX;
      Boxp_lbnd[ 1 ] = FLT_MAX;
      Boxp_ubnd[ 0 ] = FLT_MIN;
      Boxp_ubnd[ 1 ] = FLT_MIN;
   }

/* Indicate that the GRF module should re-calculate it's cached values
   (in case the state of the graphics system has changed since the last
   thing was drawn). */
   RESET_GRF;

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
   astGrfAttrs( this, AST__TEXT_ID, 1, GRF__TEXT, method, class );

/* Get the number of coordinates in the physical coordinate frame. */
   ncoord = astGetNout( this );

/* Create a PointSet to hold the supplied physical coordinates. */
   pset1 = astPointSet( 1, ncoord, "", status );

/* Allocate memory to hold pointers to the first value on each axis. */
   ptr1 = (const double **) astMalloc( sizeof( const double * )*
                                       (size_t)( ncoord ));

/* Check the pointer can be used, then store pointers to the first value
   on each axis. */
   if( astOK ){
      for( axis = 0; axis < ncoord; axis++ ){
         ptr1[ axis ] = pos + axis;
      }
   }

/* Store these pointers in the PointSet. */
   astSetPoints( pset1, (double **) ptr1 );

/* Transform the supplied data from the current frame (i.e. physical
   coordinates) to the base frame (i.e. graphics coordinates) using
   the inverse Mapping defined by the Plot. */
   mapping = astGetMapping( this, AST__BASE, AST__CURRENT );
   pset2 = Trans( this, NULL, mapping, pset1, 0, NULL, 0, method, class, status );
   mapping = astAnnul( mapping );

/* Get pointers to the graphics coordinates. */
   ptr2 = astGetPoints( pset2 );

/* Take a copy of the string excluding any trailing white space. */
   ulen = ChrLen( text, status );
   ltext = (char *) astStore( NULL, (void *) text, ulen + 1 );

/* Check the pointers can be used. */
   if( astOK ){

/* Terminate the local copy of the text string. */
      ltext[ ulen ] = 0;

/* Produce an upper-case copy of the first two characters in "just". */
      ljust[0] = (char) toupper( (int) just[0] );
      ljust[1] = (char) toupper( (int) just[1] );
      ljust[2] = 0;

/* Convert the double precision values to single precision, checking for
   bad positions. */
      if( ptr2[0][0] != AST__BAD && ptr2[1][0] != AST__BAD ){

/* Draw the text string. */
         DrawText( this, 1, astGetEscape( this ), ltext, (float) ptr2[0][0],
                   (float) ptr2[1][0], ljust, up[ 0 ], up[ 1 ], xbn, ybn,
                   NULL, method, class, status );
      }

/* Free the local copy of the string. */
      ltext = (char *) astFree( (void *) ltext );

   }

/* Annul the PointSets. */
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

/* Free the memory holding the pointers to the first value on each axis. */
   ptr1 = (const double **) astFree( (void *) ptr1 );

/* Re-establish the original graphical attributes. */
   astGrfAttrs( this, AST__TEXT_ID, 0, GRF__TEXT, method, class );

/* Restore the original value of the flag which says whether graphical
   escape sequences should be incldued in any returned text strings. */
   astEscapes( escs );

/* Return */
   return;
}

static void TextLabels( AstPlot *this, int edgeticks, int dounits[2],
                        const char *method, const char *class, int *status ){
/*
*
*  Name:
*     TextLabels

*  Purpose:
*     Draw textual labels round a grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void TextLabels( AstPlot *this, int edgeticks, int dounits[2],
*                      const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function displays a textual label for each physical axis, and a
*     title. The text strings are obtained from the Label and Title
*     attributes of the current Frame in the Plot.

*  Parameters:
*     this
*        A pointer to the Plot.
*     edgeticks
*        If tick marks and numerical labels were drawn around the edges
*        of the plotting area, this should be supplied as 1. Otherwise it
*        should be supplied as zero.
*     dounits
*        Flags indicating if the axis Units string should be included in
*        the edge labels.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Pointer to thread-specific global data */
   char *new_text;         /* Pointer to complete text string (inc. units) */
   char *just;             /* Pointer to axis label justification string */
   const char *text;       /* Pointer to text string to be displayed */
   const char *units;      /* Pointer to text string describing the units */
   double mindim;          /* Minimum dimension of plotting area */
   double xrange;          /* Width of plotting area */
   double yrange;          /* Height of plotting area */
   float txtgap;           /* Gap between bounding box and text string */
   float upx;              /* X component of text up-vector */
   float upy;              /* Y component of text up-vector */
   float xbn[ 4 ];         /* X coords at corners of new label's bounding box */
   float ybn[ 4 ];         /* Y coords at corners of new label's bounding box */
   float xref;             /* Graphics X coord. at text ref. position */
   float yref;             /* Graphics Y coord. at text ref. position */
   float xlo, xhi, ylo, yhi;/* The original bounding box (excluding labels) */
   int axis;               /* Axis index */
   int draw;               /* Should label be drawn? */
   int edge;               /* Edge to be labelled */
   int esc;                /* Interpret escape sequences? */
   int gelid;              /* ID for next graphical element to be drawn */
   int tlen;               /* No. of characetsr in label */
   int ulen;               /* No. of characetsr in units */

/* Check the global status. */
   if( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(this);

/* Get the minimum dimension of the plotting area. */
   xrange = this->xhi - this->xlo;
   yrange = this->yhi - this->ylo;
   mindim = astMIN( xrange, yrange );

/* Determine the reference point to use when measuring the gap between
   the plot and a label. Either the nearest edge of the bounding box
   containing everything else (0) or the nearest edge of the plotting
   window (1). */
   if( astGetTextGapType( this ) ) {
      xlo = this->xlo;
      xhi = this->xhi;
      ylo = this->ylo;
      yhi = this->yhi;

/* Otherwise, use the bounding box to determine the reference position.
   Take a copy of the bounding box which encloses all other parts of the
   annotated grid (this may have been extended by the above code). If
   nothing has been plotted, use an area 20 % smaller than the plotting
   area. */
   } else {

/* Take a copy of the bounding box which encloses all other parts of the
   annotated grid. If nothing has been plotted, use an area 20 % smaller
   than the plotting area. */
      if( Box_lbnd[ 0 ] != FLT_MAX ) {
         xlo = Box_lbnd[ 0 ];
         xhi = Box_ubnd[ 0 ];
         ylo = Box_lbnd[ 1 ];
         yhi = Box_ubnd[ 1 ];
      } else {
         xlo = this->xlo + 0.2*xrange;
         xhi = this->xhi - 0.2*xrange;
         ylo = this->ylo + 0.2*yrange;
         yhi = this->yhi - 0.2*yrange;
      }
   }

/* See if escape sequences are to be interpreted within the labels. */
   esc = astGetEscape( this );

/* Initialize the id value for graphical element being drawn. */
   gelid = AST__TEXTLAB1_ID;

/* Now write a label for each physical axis. */
   for( axis = 0; axis < 2 && astOK; axis++ ){

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
      astGrfAttrs( this, gelid, 1, GRF__TEXT, method, class );

/* See if the label is to be drawn. If an explicit value has not been set
   for the TextLab attribute, the default is to draw the label if tick
   marks were draw round the edge of the plotting area, and not to
   otherwise. */
      if( astTestTextLab( this, axis ) ){
         draw = astGetTextLab( this, axis );
      } else {
         draw = edgeticks;
      }

/* If so get the label. */
      if( draw ){
         text = astGetLabel( this, axis );
         tlen = ChrLen( text, status );

/* If required, get the units string and concatenate it with the label (inside
   parenthesise). Ignore trailing spaces. */
         if( dounits[ axis ] ){
            units = astGetUnit( this, axis );
            if( units && units[0] ){
               ulen = ChrLen( units, status );
               new_text = astMalloc( tlen + ulen + 4 );
               if( new_text ) memcpy( new_text, text, tlen );

               text = new_text + tlen;

               memcpy( (void *) text, " (", 2 );
               text += 2;

               memcpy( (char *) text, units, ulen );
               text += ulen;

               memcpy( (char *) text, ")", 1 );
               text += 1;

               ( (char *) text )[0] = 0;

               text = new_text;

            } else {
               new_text = astStore( NULL, (void *) text, tlen + 1 );
               new_text[ tlen ] = 0;
               text = new_text;
               units = NULL;
            }

         } else {
            new_text = astStore( NULL, (void *) text, tlen + 1 );
            new_text[ tlen ] = 0;
            text = new_text;
            units = NULL;
         }

/* Get the gap between the edge of the bounding box and the closest edge
   of the text string. */
         txtgap = (float)( mindim*astGetTextLabGap( this, axis ) );

/* Get the edge to be labelled. Edge 0 is the left hand edge. Edge 1 is the
   top edge. Edge 2 is the right-hand edge. Edge 3 is the bottom edge. */
         edge = astGetEdge( this, axis ) % 4;
         if( edge < 0 ) edge = -edge;

/* If the label is to be put on the left hand edge... */
         if( edge == 0 ){

/* Set the up vector so that the text is written from bottom to top. */
            upx = -1.0;
            upy = 0.0;

/* Justify the bottom of the whole bounding box (not just the text
   base-line). */
            just = "MC";

/* Set the x reference position just outside the box enclosing all the
   graphics drawn so far. The reference point refers to the centre of the
   text string in both directions ("CC" justification). Take account of
   whether or not the x axis is reversed. Do not allow the text to be
   written outside the whole plotting surface. */
            if( this->xrev ){
               xref = xhi + txtgap;
            } else {
               xref = xlo - txtgap;
            }

/* The Y reference position is at the mid point vertically. */
            yref = 0.5*( astMIN( yhi, this->yhi ) +
                         astMAX( ylo, this->ylo ) );

/* Do the same for the top edge. */
         } else if( edge == 1 ){
            upx = 0.0;
            upy = 1.0;
            just = "MC";
            if( this->yrev ){
               yref = ylo - txtgap;
            } else {
               yref = yhi + txtgap;
            }
            xref = 0.5*( astMIN( xhi, this->xhi ) +
                         astMAX( xlo, this->xlo ) );

/* Do the same for the right-hand edge. */
         } else if( edge == 2 ){
            upx = 1.0;
            upy = 0.0;
            just = "MC";
            if( this->xrev ){
               xref = xlo - txtgap;
            } else {
               xref = xhi + txtgap;
            }
            yref = 0.5*( astMIN( yhi, this->yhi ) +
                         astMAX( ylo, this->ylo ) );

/* Do the same for the bottom edge. */
         } else {
            upx = 0.0;
            upy = 1.0;
            just = "TC";
            if( this->yrev ){
               yref = yhi + txtgap;
            } else {
               yref = ylo - txtgap;
            }
            xref = 0.5*( astMIN( xhi, this->xhi ) +
                         astMAX( xlo, this->xlo ) );
         }

/* Display the label. */
         DrawText( this, 1, esc, text, xref, yref, just,
                   upx, upy, xbn, ybn, NULL, method, class, status );

/* Release the memory allocated to store the axis label;. */
         new_text = (char *) astFree( (void *) new_text );
         text = NULL;

      }

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, gelid, 0, GRF__TEXT, method, class );

/* Set up the id for the next graphical element to be drawn. */
      gelid = AST__TEXTLAB2_ID;

   }

/* See if the title is to be drawn. */
   if( astOK && astGetDrawTitle( this ) ){

/* If so get the title. */
      text = astGetTitle( this );

/* Create a copy from which trailing spaces have been removed. */
      tlen = ChrLen( text, status );
      new_text = (char *) astStore( NULL, (void *) text, tlen + 1 );
      new_text[ tlen ] = 0;
      text = new_text;

/* Establish the correct graphical attributes as defined by attributes
   with the supplied Plot. */
      astGrfAttrs( this, AST__TITLE_ID, 1, GRF__TEXT, method, class );

/* Determine the reference point to use when measuring the gap between
   the plot and the title. Either the nearest edge of the bounding box
   containing everything else (0) or the nearest edge of the plotting
   window (1). */
      if( astGetTextGapType( this ) ) {
         xlo = this->xlo;
         xhi = this->xhi;
         ylo = this->ylo;
         yhi = this->yhi;

/* Otherwise, use the bounding box to determine the reference position.
   Take a copy of the bounding box which encloses all other parts of the
   annotated grid (this may have been extended by the above code). If
   nothing has been plotted, use an area 20 % smaller than the plotting
   area. */
      } else {
         if( Box_lbnd[ 0 ] != FLT_MAX ) {
            xlo = Box_lbnd[ 0 ];
            xhi = Box_ubnd[ 0 ];
            ylo = Box_lbnd[ 1 ];
            yhi = Box_ubnd[ 1 ];
         } else {
            xlo = this->xlo + 0.2*xrange;
            xhi = this->xhi - 0.2*xrange;
            ylo = this->ylo + 0.2*yrange;
            yhi = this->yhi - 0.2*yrange;
         }
      }

/* Get the graphics coordinates of the bottom centre point of the title.
   The X centre is put at the mid point of the used x axis range
   (restricted to the range of the plotting area). */
      xref = 0.5*( astMIN( xhi, this->xhi ) +
                   astMAX( xlo, this->xlo ) );

/* The Y centre is put a "TitleGap" distance outside the reference
   position specified by TextGapType. */
      if( this->yrev ){
         yref = ylo - (float)( mindim*astGetTitleGap( this ) );
      } else {
         yref = yhi + (float)( mindim*astGetTitleGap( this ) );
      }

/* Display the title. Justify the bottom of the whole bounding box (not
   just the text base-line). */
      DrawText( this, 1, esc, text, xref, yref, "MC", 0.0F, 1.0F,
                xbn, ybn, NULL, method, class, status );

/* Re-establish the original graphical attributes. */
      astGrfAttrs( this, AST__TITLE_ID, 0, GRF__TEXT, method, class );

/* Release the memory allocated to store the title. */
      new_text = (char *) astFree( (void *) new_text );
      text = NULL;
   }

/* Include the labels in the bounding box held in global variables
   Box_lbnd/ubnd. */
   if( Box_lbnd[ 0 ] != FLT_MAX ) {
      Box_lbnd[ 0 ] = astMIN( Box_lbnd[ 0 ], Boxp_lbnd[ 0 ] );
      Box_ubnd[ 0 ] = astMAX( Box_ubnd[ 0 ], Boxp_ubnd[ 0 ] );
      Box_lbnd[ 1 ] = astMIN( Box_lbnd[ 1 ], Boxp_lbnd[ 1 ] );
      Box_ubnd[ 1 ] = astMAX( Box_ubnd[ 1 ], Boxp_ubnd[ 1 ] );
   } else {
      Box_lbnd[ 0 ] = Boxp_lbnd[ 0 ];
      Box_ubnd[ 0 ] = Boxp_ubnd[ 0 ];
      Box_lbnd[ 1 ] = Boxp_lbnd[ 1 ];
      Box_ubnd[ 1 ] = Boxp_ubnd[ 1 ];
   }

/* Return. */
   return;

}

static void UpdateConcat( float *xbn, float *ybn, float ux, float uy,
                          float rx, float ry, float *x, float *y,
                          float x0, float y0, float *alpha_lo,
                          float *alpha_hi, float *beta_lo, float *beta_hi,
                          int *status ){

/*
*  Name:
*     UpdateConcat

*  Purpose:
*     Update the concatenation point for a text string in preparation for
*     appending another string.

*  Synopsis:
*     #include "plot.h"
*     void UpdateConcat( float *xbn, float *ybn, float ux, float uy,
*                        float rx, float ry, float *x, float *y,
*                        float x0, float y0, float *alpha_lo, float *alpha_hi,
*                        float *beta_lo, float *beta_hi, int *status )

*  Description:
*     This function modifies the supplied concatenation point (x,y) by moving
*     it to the right along the baseline of the text by an amount equal
*     to the width of the supplied sub-string bounding box. It also updates
*     the supplied total bounding box so that it includes the supplied
*     sub-string bounding box.

*  Parameters:
*     xbn
*        Pointer to an array holding the x coord at the four corners of
*        the sub-string bounding box.
*     ybn
*        Pointer to an array holding the y coord at the four corners of
*        the sub-string bounding box.
*     ux
*        The x component of the up-vector for the text, in graphics coords.
*        The length of this vector should be equal to the height of normal
*        text drawn with this up-vector.
*     uy
*        The y component of the up-vector for the text. See "ux".
*     rx
*        The x component of the right-vector for the text. The length of this
*        vector should be equal to the height of normal text drawn with the
*        supplied up-vector.
*     ry
*        The y component of the right-vector for the text. see "rx".
*     x
*        Pointer to a float holding the x coord of the concatenation point
*        of the text just drawn. This is changed on exit so that the next
*        string will be appended to the end of the text just drawn.
*     y
*        Pointer to a float holding the y coord of the concatenation point
*        of the text just drawn. This is changed on exit so that the next
*        string will be appended to the end of the text just drawn.
*     x0
*        The X coord at the left end of the baseline of the total string.
*     y0
*        The Y coord at the left end of the baseline of the total string.
*     alpha_lo
*        Pointer to a double holding a value which gives the position of the
*        bottom edge of the total bounding box. The value is such that
*        (x0,y0) + alpha_lo*(ux,uy) is a point on the bottom edge of the
*        total bounding box. The returned value is updated so that the
*        total bounding box includes the supplied sub-string bounding box.
*     alpha_hi
*        Pointer to a double holding a value which gives the position of the
*        top edge of the total bounding box. The value is such that
*        (x0,y0) + alpha_hi*(ux,uy) is a point on the top edge of the
*        total bounding box. The returned value is updated so that the
*        total bounding box includes the supplied sub-string bounding box.
*     beta_lo
*        Pointer to a double holding a value which gives the position of the
*        left edge of the total bounding box. The value is such that
*        (x0,y0) + beta_lo*(rx,ry) is a point on the left edge of the
*        total bounding box. The returned value is updated so that the
*        total bounding box includes the supplied sub-string bounding box.
*     beta_hi
*        Pointer to a double holding a value which gives the position of the
*        right edge of the total bounding box. The value is such that
*        (x0,y0) + beta_hi*(rx,ry) is a point on the right edge of the
*        total bounding box. The returned value is updated so that the
*        total bounding box includes the supplied sub-string bounding box.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   float ahi;
   float alo;
   float alpha;
   float beta;
   float bhi;
   float blo;
   float denom;
   float dx;
   float dy;
   float xc;
   float yc;
   int ic;

/* Check the global error status. */
   if ( !astOK ) return;

/* Check the supplied up and right vectors are not parallel. */
   denom = ux*ry - uy*rx;
   if( denom != 0.0 ) {

/* Get the coords at the centre of the sub-string bounding box. */
      xc = ( xbn[ 0 ] + xbn[ 1 ] + xbn[ 2 ] + xbn[ 3 ] )/4.0;
      yc = ( ybn[ 0 ] + ybn[ 1 ] + ybn[ 2 ] + ybn[ 3 ] )/4.0;

/* For each of the 4 corners of the sub-string bounding box, we consider the
   vector from the centre of the bounding box to the corner. We want to express
   this vector, vx, as a sum of a vector in the up direction and a vector
   in the right direction:

      vx = alpha*ux + beta+rx
      vy = alpha*uy + beta+ry

   where alpha and beta are constants which are different for each
   corner vector. We also want to find the minimum and maximum alpha and
   beta covered by the box. First initialise the limits. */
      alo = 0.0;
      ahi = 0.0;
      blo = 0.0;
      bhi = 0.0;

/* Now find alpha and beta for each of the four corners. */
      for( ic = 0; ic < 4; ic++ ) {
         dx = xbn[ ic ] - xc;
         dy = ybn[ ic ] - yc;
         alpha = ( dx*ry - dy*rx ) /denom;
         beta = ( dy*ux - dx*uy ) /denom;

/* Extend the bounds in alpha and beta. */
         if( alpha < alo ) alo = alpha;
         if( alpha > ahi ) ahi = alpha;
         if( beta < blo ) blo = beta;
         if( beta > bhi ) bhi = beta;

/* The bottom left corner has negative values for both alpha and beta.
   Commence the process of updating the concatenation point by subtracting
   off the coordinates at the bottom left corner. For zero height bounding
   boxes (such as may be produced if the text is completely blank), the
   "alpha" value should be zero, but may be slightly non-zero due to
   rounding errors. Allow for this (assuming non-blank text will always
   produce a boundiong box that is at least 1.0E-4 of the up vector in
   height). We do the same for bounding box width (although zero width
   boxes will probably not occur). */
         if( alpha < 1.0E-4 ) {
            if( beta < 1.0E-4 ) {
               *x -= xbn[ ic ];
               *y -= ybn[ ic ];

/* The bottom right corner has negative alpha and positive beta. Complete
   the process of updating the concatenation point by adding on the
   coordinates at the bottom right corner. */
            } else if( beta > -1.0E-4 ) {
               *x += xbn[ ic ];
               *y += ybn[ ic ];
            }
         }
      }

/* Also express the vector from (x0,y0) to (xc,yc) as a sum of a vector
   in the up direction and a vector in the right direction:

      xc - x0 = alpha*ux + beta*rx
      yc - y0 = alpha*uy + beta*ry

   Find alpha and beta. */

      dx = xc - x0;
      dy = yc - y0;
      alpha = ( dx*ry - dy*rx ) /denom;
      beta = ( dy*ux - dx*uy ) /denom;

/* We can now express the vector from (x0,y0) to each of the 4 corners as
   a sum of alpha*up and beta*right. Form the bounds of the sub-string in
   terms of up-vectors and right vectors from (x0,y0) instead of from the
   centre of the box. */
      alo += alpha;
      ahi += alpha;
      blo += beta;
      bhi += beta;

/* Extend the supplied alpha and beta bounding box to include these limits. */
      if( alo < *alpha_lo ) *alpha_lo = alo;
      if( ahi > *alpha_hi ) *alpha_hi = ahi;
      if( blo < *beta_lo ) *beta_lo = blo;
      if( bhi > *beta_hi ) *beta_hi = bhi;
   }
}

static void Ticker( AstPlot *this, int edge, int axis, double value,
                    double *gap, double tklen, int majtick, int save,
                    EdgeCrossingsStatics **pstatics, const char *method,
                    const char *class, int *status ){
/*
*
*  Name:
*     Ticker

*  Purpose:
*     Draw edge tick marks for a given axis value.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     void Ticker( AstPlot *this, int edge, int axis, double value,
*                  double *gap, double tklen, int majtick, int save,
*                  EdgeCrossingsStatics **pstatics, const char *method,
*                  const char *class, int *status ){

*  Class Membership:
*     Plot member function.

*  Description:
*     This function draws tick marks at all occurences of a given
*     physical axis value on a given edge of the plotting area.

*  Parameters:
*     this
*        A pointer to the Plot.
*     edge
*        The edge of the plotting area to be ticked. Edge 0 is the left hand
*        edge. Edge 1 is the top edge. Edge 2 is the right-hand edge. Edge 3
*        is the bottom edge.
*     axis
*        The index of the axis to which "value" refers. The tick mark extends
*        parallel to this axis.
*     value
*        The physical axis value at which to place the tick mark.
*     gap
*        Pointer to array of two values holding the gap between major
*        tick marks on the two axes.
*     tklen
*        The length of the tick, in graphics units.
*     majtick
*        Non-zero if the tick mark being drawn is a major tick, and zero
*        if it is a minor tick.
*     save
*        If non-zero, the tick mark position will be saved in the Plot structure.
*     pstatics
*        Address of a pointer to a structure holding values for variables
*        which were statically defined within this function prior to the
*        thread-safe version of AST. If the pointer is supplied as NULL,
*        then a new structure is allocated and initialised.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   double *cross;         /* Pointer to crossings information */
   double *vx;            /* Pointer to next X vector component value */
   double *vy;            /* Pointer to next Y vector component value */
   double *x;             /* Pointer to next X value */
   double *y;             /* Pointer to next Y value */
   double xe;             /* X at tick end */
   double ye;             /* Y at tick end */
   int j;                 /* Crossing index */
   int ncross;            /* No. of crossings of tick value and edge */

/* Check the global status. */
   if( !astOK ) return;

/* See where the current major tick value crosses the edge. */
   ncross = EdgeCrossings( this, edge, axis, value, gap, &cross, pstatics,
                           method, class, status );

/* Do nothing if the supplied axis value does not occur on the specified
   edge of the plotting area. */
   if( ncross ){

/* Draw major tick marks at the crossings. */
      x = cross;
      y = cross + 1;
      vx = cross + 2;
      vy = cross + 3;

/* Draw a tick mark at each occurence of the axis value on the specified
   edge. */
      for( j = 0; j < ncross; j++ ){

/* Check the tick mark position and directionm are defined. */
         if( *vx != AST__BAD && *vy != AST__BAD &&
              *x != AST__BAD &&  *y != AST__BAD ){

/* Ensure the tick mark will point into the plotting area, no matter which
   edge it is on. First ensure the direction vector refers to a system in
   which X increases to the left and Y increases upwards. */
            if( this->xrev ) *vx = -*vx;
            if( this->yrev ) *vy = -*vy;

/* If necessary reverse the vector so that it points into the plotting
   area. How to do this depends on which edge is being ticked. */
            if( ( edge == 0 && *vx < 0.0 ) ||   /* left-hand edge */
                ( edge == 1 && *vy > 0.0 ) ||   /* Top edge */
                ( edge == 2 && *vx > 0.0 ) ||   /* Right-hand edge */
                ( edge == 3 && *vy < 0.0 ) ){   /* Bottom edge */

               *vx = -*vx;
               *vy = -*vy;
            }

/* Now ensure the direction vector refers to a the native graphics system
   taking account of any reversal of axes. */
            if( this->xrev ) *vx = -*vx;
            if( this->yrev ) *vy = -*vy;

/* Do not draw the tick if the start of the tick is outside the bounds of
   the axis it is labelling. */
            if( ( ( edge == 1 || edge == 3 ) &&
                   *x < this->xhi && *x > this->xlo ) ||
                ( ( edge == 0 || edge == 2 ) &&
                   *y < this->yhi && *y > this->ylo ) ) {

/* Store the x and y graphics coords of the far end of the tick mark */
               xe = *x + tklen*(*vx);
               ye = *y + tklen*(*vy);

/* Ensure the far end of the tick mark is within the bounds of the axis
   it is labelling. If not, redice the length of the tick mark until it is.*/
               if( edge == 1 || edge == 3 ) {  /* Top or bottom edge */
                  if( xe > this->xhi ) {
                     ye = *y + tklen*(*vy)*( this->xhi - *x )/(xe - *x );
                     xe = this->xhi;
                  } else if( xe < this->xlo ) {
                     ye = *y + tklen*(*vy)*( this->xlo - *x )/(xe - *x );
                     xe = this->xlo;
                  }

               } else {                        /* Left or right edge */
                  if( ye > this->yhi ) {
                     xe = *x + tklen*(*vx)*( this->yhi - *y )/(ye - *y );
                     ye = this->yhi;
                  } else if( ye < this->ylo ) {
                     xe = *x + tklen*(*vx)*( this->ylo - *y )/(ye - *y );
                     ye = this->ylo;
                  }
               }

/* Draw the tick mark as a straight line of the specified length. */
               if( save ) SaveTick( this, axis, *x, *y, majtick, status );
               if( *x != xe || *y != ye ) {
                  Bpoly( this, (float) *x, (float) *y, status );
                  Apoly( this, (float) xe, (float) ye, status );
                  Opoly( this, status );
               }
            }

/* Move on to the next crossing. */
            x += 4;
            y += 4;
            vx += 4;
            vy += 4;
         }
      }

/* Free the memory holding the crossings. */
      if( cross ) cross = (double *) astFree( (void *) cross );

   }

/* Return. */
   return;

}

static TickInfo *TickMarks( AstPlot *this, int axis, double *cen, double *gap,
                            int *inval, GetTicksStatics **pstatics,
                            const char *method, const char *class, int *status ){
/*
*  Name:
*     TickMarks

*  Purpose:
*     Obtain a list of tick mark values and labels for a single axis in a 2-D
*     physical coordinate Frame.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     TickInfo *TickMarks( AstPlot *this, int axis, double *cen, double *gap,
*                          int *inval, GetTicksStatics **pstatics,
*                          const char *method, const char *class, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     A set of tick marks values and corresponding formatted labels are
*     found for an axis which result in all adjacent labels being different,
*     but using the minimum number of digits of precision in the formatting.
*     This algorithm is over-ridden if the caller has set an explicit Format
*     string for the axis. The gap between tick marks can be specified by
*     the caller or a default value may be found automatically.

*  Parameters:
*     this
*        The Plot.
*     axis
*        The zero-based index of the axis to use.
*     cen
*        Pointer to the supplied axis value at which to put a single
*        central tick. Other ticks will be placed evenly on either side of
*        this tick. If AST__BAD is provided, a value will be used which
*        would put a tick at an axis value of zero. The used value is
*        returned.
*     gap
*        The supplied values for the gaps between ticks on the axis. If
*        this is AST__BAD a suitable default value will be used and
*        returned in place of the AST__BAD value.
*     inval
*        A pointer to a location at which to return a flag indicating if
*        any invalid physical coordinates were encountered while deciding on
*        the tick values.
*     pstatics
*        Address of a pointer to a structure holding static data values
*        used within the GetTicks function. A NULL pointer should be supplied
*        on the first invocation (dynamic memory will then be allocated to
*        hold ths structure). The memory is freed when a NULL value for
*        "this" is supplied.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A pointer to a TickInfo structure holding information about the tick
*     marks (no. of major and minor ticks, the major tick mark values and
*     labels). This structure should be freed, together with its contents,
*     using astFree when it is no longer needed.

*  Notes:
*     -  The returned labels are NOT abbreviated to remove identical
*     leading fields.
*     -  This function allocates some static resources on its first
*     invocation, which should be released when no longer needed, or when
*     a different Plot is supplied, by calling this function with a NULL
*     pointer for parameter "this". All other parameters (except axis) are
*     ignored.
*     -  This function assumes that the physical coordinate system is 2
*     dimensional, and it should not be used if this is not the case.
*     -  An error is reported if the region containing valid physical
*     coordinates is too small to use.
*     -  If an error has already occurred, or if this function should fail
*     for any reason, then a NULL pointer is returned.
*/

/* Local Constants: */
#define MAXFLD 10

/* Local Variables: */
   AstAxis *ax;        /* Pointer to the axis. */
   AstFrame *frame;    /* Pointer to the current Frame in the Plot */
   TickInfo *ret;      /* Pointer to the returned structure. */
   char **labels;      /* Pointer to list of formatted labels */
   char **newlabels;   /* Pointer to new list of shortened formatted labels */
   char **oldlabels;   /* Pointer to old list of formatted labels */
   char *fields[ MAXFLD ]; /* Pointers to starts of fields in a label */
   char *old_format;   /* Original Format string */
   char *used_fmt;     /* Copy of format string actually used */
   const char *a;      /* Pointer to next character to consider */
   const char *fmt;    /* Format string actually used */
   double *ticks;      /* Pointer to major tick mark values */
   double *minticks;   /* Pointer to minor tick mark values */
   double junk;        /* Unused value */
   double refval;      /* Value for other axis to use when normalizing */
   double used_gap;    /* The gap size actually used */
   int bot_digits;     /* Digits value which makes labels as short as possible */
   int digits;         /* New Digits value */
   int digset;         /* Did the format string fix the no. of digits to use? */
   int fmtset;         /* Was a format set? */
   int i;              /* Tick index. */
   int nc[ MAXFLD ];   /* Lengths of fields in a label */
   int nf;             /* Number of fields in a label */
   int nmajor;         /* No. of major tick marks */
   int nminor;         /* No. of minor tick marks */
   int ok;             /* Are all adjacent labels different? */
   int reset_fmt;      /* Re-instate the original state of the Format attribute? */


/* If a NULL pointer has been supplied for "this", release the resources
   allocated within GetTicks, and return. */
   if( !this ){
      (void) GetTicks( NULL, axis, NULL, &ticks, &nmajor, &minticks, &nminor,
                       0, inval, &refval, pstatics, method, class, status );
      return NULL;
   }

/* Check the global status. */
   if( !astOK ) return NULL;

/* Initialise the returned pointer. */
   ret = NULL;

/* Get a pointer to the current Frame from the Plot. */
   frame = astGetFrame( this, AST__CURRENT );

/* Initialise a flag to indicate that all adjacent labels are different. */
   ok = 0;

/* Initialise the pointer to the list of formatted tick mark values to
   indicate that no memory has yet been obtained. */
   labels = NULL;

/* Initialise the pointer to a copy of the used format string to indicate
   that no memory has yet been obtained. */
   used_fmt = NULL;

/* Get a pointer to the axis. */
   ax = astGetAxis( frame, axis );

/* See if a value has been set for the axis Format. */
   fmtset = astTestFormat( frame, axis );

/* Get an initial set of tick mark values. This also establishes defaults for
   LogTicks and LogLabel attributes, and so must be done before the
   following block which uses the LogLabel attribute. */
   used_gap = GetTicks( this, axis, cen, &ticks, &nmajor, &minticks, &nminor,
                        fmtset, inval, &refval, pstatics, method, class, status );

/* See if exponential labels using superscript powers are required.  */
   old_format = NULL;
   reset_fmt = 0;
   if( astGetLogLabel( this, axis ) && astGetEscape( this ) &&
       GCap( this, GRF__SCALES, 1, status ) ) {

/* Save a copy of the Frame's Format value, if set. It will be
   re-instated at the end of this function. */
      if( fmtset ) {
         fmt = astGetFormat( frame, axis );
         old_format = astStore( NULL, (void *) fmt, strlen(fmt) + 1 );
      }

/* Temporarily use a format of "%&g" to get "10**x" style axis labels,
   with super-scripted "x". */
      astSetFormat( frame, axis, "%&g" );

/* Not all subclasses of Frame support this format specifier, so format a
   test value, and see if it has two fields, the first of which is "10".
   If not, we cannot use log labels so re-instate the original format. */
      nf = astFields( frame, axis, "%&g", astFormat( frame, axis, 1.0E4 ),
                      MAXFLD, fields, nc, &junk );
      if( nf != 2 || nc[ 0 ] != 2 || strncmp( fields[ 0 ], "10", 2 ) ) {
         if( old_format ) {
            astSetFormat( frame, axis, old_format );
            old_format = astFree( old_format);
         } else {
            astClearFormat( frame, axis );
         }

/* If the "%&g" format is usable, note that we should reset the Format
   back to its original state before leaving this function. */
      } else {
         reset_fmt = 1;
      }
   }

/* If a value has been set for the axis Format, see if the format string
   contains a wildcard precision specifier ".*". If so, we are free to
   vary the number of digits used in the label in order to produce
   distinct labels. If no value has been set for the axis Format, we are
   also free to vary the number of digits. */
   digset = 0;
   if( fmtset ) {
      fmt = astGetFormat( frame, axis );
      if( fmt ) {
         digset = 1;
         a = fmt;
         while( (a = strchr( a, '.' )) ){
            if( *(++a) == '*' ) {
               digset = 0;
               break;
            }
         }
      }
   }

/* If the axis precision has been specified, either through the Format string
   or Digits value, or the Frame Digits value, we should use it so that the
   user's attempts to get a specific result are not foiled. */
   if( digset || astTestAxisDigits( ax ) || astTestDigits( frame ) ){

/* Reserve memory to hold pointers to the formatted labels. */
      labels = (char **) astMalloc( sizeof(char *)*(size_t)nmajor );

/* Format the labels. We do not check that all adjacent labels are distinct
   in order not to foil the users choice of format. That is, "ok" is set
   non-zero by the call to CheckLabels, even if some identical adjacent
   labels are found. */
      ok = CheckLabels( this, frame, axis, ticks, nmajor, 1, labels, refval, status );

/* Note the format used. */
      fmt = astGetFormat( frame, axis );
      if( fmt ) used_fmt = (char *) astStore( used_fmt, (void *) fmt, strlen( fmt ) + 1 );

/* If no precision has been specified for the axis, we need to find a
   Digits value which gives different labels, but without using any more
   digits than necessary. */
   } else if( astOK ){

/* Reserve memory to hold pointers to an initial set of labels formatted
   with the default digits value. */
      labels = (char **) astMalloc( sizeof(char *)*(size_t)nmajor );

/* Produce these default labels. */
      CheckLabels( this, frame, axis, ticks, nmajor, 1, labels, refval, status );

/* The first task is to decide what the smallest usable number of digits
   is. Starting at the default number of digits used above to produce the
   default labels, we reduce the number of digits until one or more of the
   formatted labels *increases* in length. This can happen for instance if
   printf decides to include an exponent in the label. The *absolute*
   minimum value 1. Set this first. */
      bot_digits = 1;
      oldlabels = labels;
      for( digits = astGetDigits( frame ) - 1; digits > 0; digits-- ){
         astSetAxisDigits( ax, digits );

/* CheckLabels2 formats the labels with the decreased number of digits,
   and compares them with the old labels in "labels". If any of the new labels
   are longer than the corresponding old labels, then a null pointer is
   returned. Otherwise, a pointer is returned to the new set of labels. */
         newlabels = CheckLabels2( this, frame, axis, ticks, nmajor,
                                   oldlabels, refval, status );

/* Free the old labels unless they are the orignal labels (which are
   needed below). */
         if( oldlabels != labels ) {
            for( i = 0; i < nmajor; i++ ){
               if( oldlabels[ i ] ) oldlabels[ i ] = (char *) astFree( (void *) oldlabels[ i ] );
            }
            oldlabels = (char **) astFree( (void *) oldlabels );
         }

/* If any of the labels got longer as a result of reducing the digits
   value, then use the previous number of digits as the lowest possible
   number of digits. Break out of the loop. */
         if( !newlabels ) {
            bot_digits = digits + 1;
            break;
         }

/* If none of the labels got longer, we arrive here. Use the shorter labels
   for the next pass round this loop. */
         oldlabels = newlabels;
      }

/* Free any remaining labels. */
      if( oldlabels && oldlabels != labels ) {
         for( i = 0; i < nmajor; i++ ){
            if( oldlabels[ i ] ) oldlabels[ i ] = (char *) astFree( (void *) oldlabels[ i ] );
         }
         oldlabels = (char **) astFree( (void *) oldlabels );
      }

/* Now loop round increasing the number of digits in the formatted labels
   from the lowest usable value found above until all adjacent labels are
   different. An arbitrary upper limit of 1000 is used for Digits to stop it
   looping for ever. */
      for( digits = bot_digits; digits < 1000; digits++ ){

/* Store the new Digits value. */
         astSetAxisDigits( ax, digits );

/* Free memory used to hold the current set of labels. A new set will be
   created by the following call to CheckLabels. */
         if( labels ) {
            for( i = 0; i < nmajor; i++ ) labels[ i ] = astFree( labels[ i ] );
         }

/* Break out of the loop if a Digits value has been found which results
   in all adjacent labels being different. Note the format used (we know
   the Format attribute is currently unset, but the default Format string
   reflects the current value of the Digits attribute). */
         if( CheckLabels( this, frame, axis, ticks, nmajor, 0, labels, refval, status ) ) {
            ok = 1;
            fmt = astGetFormat( frame, axis );
            used_fmt = (char *) astStore( NULL, (void *) fmt, strlen( fmt ) + 1 );
            break;
         }
      }

/* Clear the Digits value. */
      astClearAxisDigits( ax );
   }

/* Annul the pointer to the Axis. */
   ax = astAnnul( ax );

/* Re-instate the original format specifier if required. */
   if( reset_fmt ) {
      if( old_format ) {
         astSetFormat( frame, axis, old_format );
         old_format = astFree( old_format);
      } else {
         astClearFormat( frame, axis );
      }
   }

/* If suitable labels were found... */
   if( ok && astOK ) {

/* Store the used gap size. */
      *gap = used_gap;

/* If the caller has specified the number of minor tick marks to use,
   use the specified value rather than the value found above. */
      if( astTestMinTick( this, axis ) ){
         nminor = astGetMinTick( this, axis );
      }

/* Allocate memory for the returned structure. */
      ret = (TickInfo *) astMalloc( sizeof( TickInfo ) );

/* If the pointer can be used, store the information. */
      if( astOK ){
         ret->nmajor = nmajor;
         ret->nminor = nminor;
         ret->ticks = ticks;
         ret->minticks = minticks;
         ret->labels = labels;
         ret->fmt = used_fmt;
         used_fmt = NULL;
         ret->start = NULL;
         ret->length = NULL;
         ret->nsect = 0;
         ret->gap = used_gap;
      }

/* If no suitable labels were found report an error. */
   } else if( astOK ){
      if( fmtset ){
         astError( AST__PLFMT, "%s(%s): No numerical labels can be produced "
                   "for axis %d using the supplied %s format string '%s'.", status,
                   method, class, axis + 1, astGetClass( frame ),
                   astGetFormat( frame, axis ) );
      } else {
         astError( AST__PLFMT, "%s(%s): No suitable format can be found to "
                   "produce numerical labels for axis %d of a %s.", status,
                   method, class, axis + 1, astGetClass( frame ) );
      }
   }

/* Release any remaining resources. */
   frame = astAnnul( frame );
   if( used_fmt ) used_fmt = astFree( used_fmt );

/* If an error has occurred, release the returned information. */
   if( !astOK ){
      ticks = (double *) astFree( (void *) ticks );
      minticks = (double *) astFree( (void *) minticks );
      if( labels ){
         for( i = 0; i < nmajor; i++ ) {
            labels[ i ] = (char *) astFree( (void *) labels[ i ] );
         }
         labels = (char **) astFree( (void *) labels );
         if( ret ) (void ) astFree( (void *) ret->fmt );
      }
      ret = (TickInfo *) astFree( (void *) ret );
   }

/* Return the structure. */
   return ret;

/* Undefine local constants. */
#undef MAXFLD

}

static int TraceBorder( AstPlot *this, AstMapping *map, double xlo, double xhi,
                        double ylo, double yhi, int dim, double tol,
                        int edges[ 4 ], const char *method, const char *class,
                        int *status ) {
/*
*  Name:
*     TraceBorder

*  Purpose:
*     Trace the boundary between good and bad physical coordinates through a
*     fine grid.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TraceBorder( AstPlot *this, AstMapping *map, double xlo, double xhi,
*                      double ylo, double yhi, int dim, double tol,
*                      int edges[ 4 ], const char *method, const char *class,
*                      int *status ) {

*  Class Membership:
*     Plot member function.

*  Description:
*     A rectangular grid of points in graphics coords is created covering
*     the region specified by (xlo,xhi,ylo,yhi), using "dim" points along
*     each axis. This grid of points is converted into physical (WCS)
*     coords, and a flag is associatred with each point saying whether
*     the WCS coords are good or bad. The cells in this grid are then
*     scanned from bottom left to top right in raster fashion (each cell
*     has a grid point at each of its 4 corners). If a cell has a mix of
*     bad and good corners, the good/bad boundary must pass through it.
*     If the grid is sufficiently fine (as defined by "tol") then this
*     function draws a single straight line through each cell as an
*     approximation to the good bad boundary. This line joins the centres
*     of the two cells edges through which the boundary passes (as
*     indicated by the fact that one end of the edge has good WCS coords
*     and the other end has bad WCS coords). If the grid is not
*     sufficiently fine to meet the "tol" requirement, then this function
*     is invoked recursively to draw the curve through each cell through
*     which the boundary passes.

*  Parameters:
*     this
*        The plot.
*     map
*        The Graphics->WCS mapping.
*     xlo
*        The lower bounds on the graphics X axis of the rectangle being
*        considered.
*     xhi
*        The upper bounds on the graphics X axis of the rectangle being
*        considered.
*     ylo
*        The lower bounds on the graphics Y axis of the rectangle being
*        considered.
*     yhi
*        The upper bounds on the graphics Y axis of the rectangle being
*        considered.
*     dim
*        The number of points along one edge of the fine grid.
*     tol
*        The plotting tolerance. Once each cell is smaller than this
*        distance (in graphics coords), the cell is drawn. Otherwise,
*        this function is invoked recursively to draw the cell using a
*        finer grid.
*     edges
*        A pointer to an array of 4 int, in which will be returned
*        flags indicating if the good/bad boundary intersects any of the
*        edges of the grid. These flags are stored in the order left,
*        top, right, bottom.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstPointSet *pset1;
   AstPointSet *pset2;
   double **ptr2;
   double *px1;
   double *px2;
   double *py1;
   double *py2;
   double cxhi;
   double cxlo;
   double cyhi;
   double cylo;
   double dx;
   double dy;
   float xc;
   float yc;
   int *bndry;
   int *drawn;
   int bad1;
   int bad2;
   int bad3;
   int bad4;
   int icell;
   int icol;
   int irow;
   int lastcell;
   int ncell;
   int recurse;
   int result;
   int sedges[ 4 ];
   int totcells;

/* Initialise returned edge flags */
   edges[ 0 ] = 0;
   edges[ 1 ] = 0;
   edges[ 2 ] = 0;
   edges[ 3 ] = 0;

/* Initialise the returned flag to indicate that no bad regions were
   found. */
   result = 0;

/* Check the global status. */
   if ( !astOK ) return result;

/* Create a grid of graphics and WCS coords covering the specified region
   of graphics coords. "ptr2" is used to access the WCS coords at each
   point in the grid. */
   ptr2 = MakeGrid( this, NULL, map, 0, dim, xlo, xhi, ylo, yhi,
                    2, &pset1, &pset2, 0, method, class, status );

/* The number of cells along each axis of the grid is one less than the
   number of points. Also get the number of cells in the whole grid. */
   ncell = dim - 1;
   totcells = ncell*ncell;

/* Store the dimensions of each cell in graphics coords. */
   dx = ( xhi - xlo )/ncell;
   dy = ( yhi - ylo )/ncell;

/* Set a flag indicating if the cell size is larger than the required
   plotting tolerance. If so, we will call this function recursively to
   draw the curve using a finer grid. */
   recurse = ( dx > tol || dy > tol );

/* If we have not yet reached the plotting tolerance, allocate work arrays
   with one element for each cell in the grid. */
   if( recurse ) {
      bndry = astMalloc( sizeof( int )*totcells );
      drawn = astMalloc( sizeof( int )*totcells );
   } else {
      bndry = NULL;
      drawn = NULL;
   }

/* Check pointers can be used safely. */
   if( astOK ) {

/* If required, initialise work arrays to hold zero. */
      if( recurse ) {

/* Initialise "boundary passes through cell" flags to zero. */
         memset( bndry, 0, sizeof( int )*totcells );

/* Initialise "cell has been drawn" flags to zero. */
         memset( drawn, 0, sizeof( int )*totcells );
      }

/* Store the Y graphics coords at the bottom and top of the first row. */
      cylo = ylo;
      cyhi = ylo + dy;

/* Store pointers to the physical coords at the bottom left corner of the
   first cell in the first row. */
      px1 = ptr2[ 0 ];
      py1 = ptr2[ 1 ];

/* Store pointers to the physical coords at the top left corner of the
   first cell in the first row. */
      px2 = px1 + dim;
      py2 = py1 + dim;

/* Store the index of the last cell in a row or column. */
      lastcell = ncell - 1;

/* Initialise index of next cell. */
      icell = 0;

/* Loop round every row of cells in this grid. */
      for( irow = 0; irow < ncell; irow++ ) {

/* See if the physical coords are bad at the bottom left corner of the
   first cell in this row. At the same time, increment the pointers so
   they refer to the bottom right corner of the first cell in this row. */
         bad1 = ( *px1 == AST__BAD || *py1 == AST__BAD );

/* Increment the pointers. Do not do it in the above "if" statement since
   the or (!!) means that the second expression may never be evaluated. */
         px1++;
         py1++;

/* See if the physical coords are bad at the top left corner of the
   first cell in this row. At the same time, increment the pointers so
   they refer to the top right corner of the first cell in this row. */
         bad2 = ( *px2 == AST__BAD || *py2 == AST__BAD );
         px2++;
         py2++;

/* Loop round every cell in the current row of cells. */
         for( icol = 0; icol < ncell; icol++, icell++ ) {

/* See if the physical coords are bad at the bottom right corner of the
   current cell in this row. At the same time, increment the pointers so
   they refer to the bottom right corner of the next cell in this row. */
            bad3 = ( *px1 == AST__BAD || *py1 == AST__BAD );
            px1++;
            py1++;

/* See if the physical coords are bad at the top right corner of the
   current cell in this row. At the same time, increment the pointers so
   they refer to the top right corner of the next cell in this row. */
            bad4 = ( *px2 == AST__BAD || *py2 == AST__BAD );
            px2++;
            py2++;

/* Set the returned flag non-zero if any invalidpositions are found. */
            if( bad1 || bad2 || bad3 || bad4 ) result = 1;

/* If there are a mixture of good and bad corners, the good/bad boundary
   must pass through the current cell. */
            if( bad2 != bad1 || bad3 != bad1 || bad4 != bad1 ) {

/* If we have not yet reached the required plotting tolerance, set a flag
   to indicate that the boundary should be plotted through this cell
   using a recirsive call to this function. */
               if( recurse ) {
                  bndry[ icell ] = 1;

/* If we have reached the required plotting tolerance, draw the boundary
   as a straight line between the centres of the edges through which the
   boundary enteres and leaves the current cell. */
               } else {

/* Get the upper and lower graphics X bounds of the current cell. */
                  cxlo = xlo + icol*dx;
                  cxhi = cxlo + dx;

/* If an edge of the current cell has good coords at one end but bad
   coords at the other, the boundary is assumed to pass through the edge
   at its centre. Normally, we expect only two cell edges to have this
   property (i.e the boundary enters the cell through one edge and leaves
   through the other). However, sometimes all four edges may have this
   property. In this case, two sections of the boundary must pass through
   the cell, and there is no way of knowing which edges connect together
   (short of further recursion), and we arbitrarily decide to join opposite
   edges. */
                  if( bad1 == bad4 && bad2 == bad3 ) {

/* Draw a horizontal line through the cell centre */
                     yc = 0.5*( cylo + cyhi );
                     Bpoly( this, (float) cxlo, yc, status );
                     Apoly( this, (float) cxhi, yc, status );

/* Draw a vertical line through the cell centre */
                     xc = 0.5*( cxlo + cxhi );
                     Bpoly( this, xc, (float) cylo, status );
                     Apoly( this, xc, (float) cyhi, status );

/* If the boundary passes through the left hand edge, it must also have
   passed through the right edge of the previous cell in the row (unless
   this is the first cell in the row), so we do not need to begin a new
   polyline (we can just extend the existing polyline). */
                  } else if( bad1 != bad2 ) {

/* If this is the first cell in the row, begin a new polyline. */
                     yc = 0.5*( cylo + cyhi );
                     if( icol == 0 ) Bpoly( this, (float) cxlo, yc, status );

/* and through the top edge, draw a line between the centres of the left
   and top edges. */
                     if( bad2 != bad4 ) {
                        xc = 0.5*( cxlo + cxhi );
                        Apoly( this, xc, (float) cyhi, status );

/* or through the right edge, draw a line between the centres of the left
   and right edges. */
                     } else if( bad3 != bad4 ) {
                        Apoly( this, (float) cxhi, yc, status );

/* Otherwise, draw a line between the centres of the left and bottom edges. */
                     } else {
                        xc = 0.5*( cxlo + cxhi );
                        Apoly( this, xc, (float) cylo, status );
                     }

/* If the boundary passes through the top edge (we do not need to check
   the left edge because that was done above)... */
                  } else if( bad4 != bad2 ) {

/* and through the right edge, draw a line between the centres of the top
   and right edges. */
                     if( bad3 != bad4 ) {
                        xc = 0.5*( cxlo + cxhi );
                        yc = 0.5*( cylo + cyhi );
                        Bpoly( this, xc, (float) cyhi, status );
                        Apoly( this, (float) cxhi, yc, status );

/* Otherwise, draw a line between the centres of the top and bottom edges. */
                     } else {
                        xc = 0.5*( cxlo + cxhi );
                        Bpoly( this, xc, (float) cyhi, status );
                        Apoly( this, xc, (float) cylo, status );
                     }

/* If the boundary passes through the right edge it must also pass
   throught the bottom edge since all other combinations will have been
   trapped above. */
                  } else {
                     xc = 0.5*( cxlo + cxhi );
                     yc = 0.5*( cylo + cyhi );
                     Bpoly( this, xc, (float) cylo, status );
                     Apoly( this, (float) cxhi, yc, status );
                  }

/* If the current cell is on the edge of the grid, set flags in the
   returned "edges" array to indicate that the boundary passes out of
   the grid on the appropriate edge. */
                  if( icol == 0 ) {
                     if( bad1 != bad2 ) edges[ 0 ] = 1;  /* Left edge */
                  } else if( icol == lastcell ) {
                     if( bad3 != bad4 ) edges[ 2 ] = 1;  /* Right edge */
                  }

                  if( irow == 0 ) {
                     if( bad1 != bad3 ) edges[ 3 ] = 1;  /* Bottom edge */
                  } else if( irow == lastcell ) {
                     if( bad2 != bad4 ) edges[ 1 ] = 1;  /* Top edge */
                  }
               }
            }

/* The flags for the right hand corners of the current cell can be
   re-used as the flags for the left hand corners of the next cell. */
            bad1 = bad3;
            bad2 = bad4;
         }

/* Store the Y graphics coords at the bottom and top of the next row. */
         cylo = cyhi;
         cyhi = cylo + dy;
      }

/* If we have not yet reached the required plotting tolerance, call this
   function recursively to draw the boundary through the cells identified
   above. On each pass through this loop, we may discover more boundary
   cells in the grid, in addition to those found above. Continue looping
   until no further boundary cells are found. */
      while( recurse ) {

/* Assume that the current pass though this loop will result in all boundary
   cells being draw, in which case we can then leave the loop. */
         recurse = 0;

/* Store the Y graphics coords at the bottom and top of the first row. */
         cylo = ylo;
         cyhi = ylo + dy;

/* Initialise the cell index */
         icell = 0;

/* Loop round every row of cells in this grid. */
         for( irow = 0; irow < ncell; irow++ ) {

/* Loop round every cell in the current row of cells. */
            for( icol = 0; icol < ncell; icol++, icell++ ) {

/* If the good/bad boundary passes through the current cell we need to
   draw it unless it has already been drawn. */
               if( bndry[ icell ] && ! drawn[ icell ] ){

/* Get the upper and lower graphics X bounds of the current cell. */
                  cxlo = xlo + icol*dx;
                  cxhi = cxlo + dx;

/* Call this function recursively to draw the boundary through the current
   cell, setting the returned flag non-zero if any bad positions are found. */
                  if( TraceBorder( this, map, cxlo, cxhi, cylo, cyhi, 3, tol,
                                   sedges, method, class, status ) ) result = 1;

/* The boundary may have passed out of the current cell and then back
   into the cell on the same edge (i.e. a small loop that pokes out into
   a neighbouring cell). Such neighbouring cells may not have been
   identified by the earlier section of this function, so we now ensure
   that any such cells are flagged as boundary cells. */

/* If the boundary passed out of the left edge of the cell... */
                  if( sedges[ 0 ] ) {

/* If the current cell is at the left edge of the grid, indicate that the
   boundary passes out of the left edge of the grid. */
                     if( icol == 0 ) {
                        edges[ 0 ] = 1;  /* Left edge */

/* Otherwise, if the left hand neighbour of the current cell is not
   flagged as a boundary cell, flag it now and indicate that another pass
   though the loop is needed to draw the extra cell. */
                     } else if( ! bndry[ icell - 1 ] ) {
                        bndry[ icell - 1 ] = 1;
                        recurse = 1;
                     }
                  }

/* If the boundary passed out of the top edge of the cell... */
                  if( sedges[ 1 ] ) {

/* If the current cell is at the top edge of the grid, indicate that the
   boundary passes out of the top edge of the grid. */
                     if( irow == lastcell ) {
                        edges[ 1 ] = 1;  /* Top edge */

/* Otherwise, ensure that the upper neighbour of the current cell is
   flagged as a boundary cell. */
                     } else {
                        bndry[ icell + ncell ] = 1;
                     }
                  }

/* If the boundary passed out of the right edge of the cell... */
                  if( sedges[ 2 ] ) {

/* If the current cell is at the right edge of the grid, indicate that the
   boundary passes out of the right edge of the grid. */
                     if( icol == lastcell ) {
                        edges[ 2 ] = 1;  /* Right edge */

/* Otherwise, ensure that the right hand neighbour of the current cell is
   flagged as a boundary cell. */
                     } else {
                        bndry[ icell + 1 ] = 1;
                     }
                  }

/* If the boundary passed out of the bottom edge of the cell... */
                  if( sedges[ 3 ] ) {

/* If the current cell is at the bottom edge of the grid, indicate that the
   boundary passes out of the bottom edge of the grid. */
                     if( irow == 0 ) {
                        edges[ 3 ] = 1;  /* Bottom edge */

/* Otherwise, if the lower neighbour of the current cell is not flagged
   as a boundary cell, flag it now and indicate that another pass though
   the loop is needed to draw the extra cell. */
                     } else if( ! bndry[ icell - ncell ] ) {
                        bndry[ icell - ncell ] = 1;
                        recurse = 1;
                     }
                  }

/* Indicate this cell has been drawn. */
                  drawn[ icell ] = 1;
               }
            }

/* Store the Y graphics coords at the bottom and top of the next row. */
            cylo += dy;
            cyhi = cylo + dy;
         }
      }
   }

/* Free resources */
   bndry = astFree( bndry );
   drawn = astFree( drawn );
   pset1 = astAnnul( pset1 );
   pset2 = astAnnul( pset2 );

/* Return the result. */
   return result;
}

static AstPointSet *Trans( AstPlot *this, AstFrame *frm, AstMapping *mapping,
                           AstPointSet *in, int forward, AstPointSet *out,
                           int norm, const char *method, const char *class, int *status ) {
/*
*  Name:
*     Trans

*  Purpose:
*     Use a Mapping to transform a set of points.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     AstPointSet *Trans( AstPlot *this, AstFrame *frm, AstMapping *mapping,
*                         AstPointSet *in, int forward, AstPointSet *out,
*                         int norm, const char *method, const char *class )

*  Class Membership:
*     Plot member function.

*  Description:
*     This performs the same task as the protected method astTransform
*     but uses the astTransform method for the supplied Mapping instead
*     the parent method for the Plot. This allows the Mapping to be
*     extracted from the Plot using astGetMapping once, rather than every
*     time a mapping is performed.

*  Parameters:
*     this
*        Pointer to the Plot (only used to access clipping attributes and
*        other methods).
*     frm
*        Pointer to the Current Frame in the Plot. If this is NULL, then
*        a pointer for the Current Frame is found within this function if
*        required (i.e. if "forward" and "norm" are both non-zero).
*     mapping
*        Pointer to the Mapping extracted from the Plot. If this is NULL, then
*        a pointer for the base->current Mapping is found within this function.
*     in
*        Pointer to the PointSet holding the input coordinate data.
*     forward
*        A non-zero value indicates that the forward coordinate
*        transformation should be applied while a zero value requests the
*        inverse transformation.
*     out
*        Pointer to a PointSet which will hold the transformed (output)
*        coordinate values. A NULL value may also be given, in which case a
*        new PointSet will be created by this function.
*     norm
*        The normalisation of returned physical coordinates is only done
*        if "norm" is non-zero. Otherwise they are left as returned by
*        astTransform.
*     method
*        Pointer to a string holding the name of the calling method.
*        This is only for use in constructing error messages.
*     class
*        Pointer to a string holding the name of the supplied object class.
*        This is only for use in constructing error messages.

*  Returned Value:
*     Pointer to the output (possibly new) PointSet.

*  Notes:
*     -  Clipping is only performed as set up using the astClip method.
*     In particular, the clipping specified by the arguments to the astPlot
*     constructor function is NOT performed. This is done in order to improve
*     the efficiency of the curve drawing method astGridLine.
*     -  A null pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*     -  The number of coordinate values per point in the input PointSet must
*     match the number of coordinates for the Plot being applied.
*     -  If an output PointSet is supplied, it must have space for sufficient
*     number of points and coordinate values per point to accommodate the
*     result. Any excess space will be ignored.
*/

/* Local Variables: */
   AstFrame *cfr;                /* Pointer to the Current Frame */
   AstFrame *fr;                 /* Pointer to the clipping Frame */
   AstMapping *map;              /* Pointer to output->clip mapping */
   AstPointSet *clip;            /* Positions in clipping Frame */
   AstPointSet *result;          /* Positions in output Frame */
   double **ptr_clip;            /* Pointer to clipping Frame data */
   double **ptr_out;             /* Pointer to output coordinate data */
   double *work;                 /* Pointer to array holding an o/p position */
   double axval;                 /* Axis value in clipping frame */
   double lbnd;                  /* Lower bound on current clipping axis */
   double ubnd;                  /* Upper bound on current clipping axis */
   int axin;                     /* Is the axis value within the allowed range? */
   int clip_norm;                /* Normalise the clipping positions? */
   int clip_or;                  /* Combine axes using a logical OR? */
   int clipit;                   /* Should the current point be clipped? */
   int i;                        /* Point index */
   int iframe;                   /* Validated index for clipping Frame */
   int j;                        /* Axis index */
   int naxes;                    /* Number of axes in clipping Frame */
   int ncoord_out;               /* Number of coordinates per output point */
   int npoint;                   /* Number of points */

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* Ensure we have a Mapping */
   if( !mapping ) mapping = astGetMapping( this, AST__BASE, AST__CURRENT );

/* Apply the parent mapping using the stored pointer to the Transform member
   function inherited from the parent FrameSet class. */
   result = astTransform( mapping, in, forward, out );

/* Get the dimensions of the returned data, and an array of pointers to
   the axis values. */
   ncoord_out = astGetNcoord( result );
   npoint = astGetNpoint( result );
   ptr_out = astGetPoints( result );

/* If we have done a forward mapping, we now normalise the returned physical
   positions if required using the astNorm method for the supplied object. */
   if( forward && norm ){

/* If no Frame was supplied, get a pointer to the Current Frame. Otherwise,
   use the supplied pointer. */
      if( !frm ) {
         cfr = astGetFrame( this, AST__CURRENT );
      } else {
         cfr = frm;
      }

/* Get work space to hold a single positions. */
      work = (double *) astMalloc( sizeof(double)*(size_t)ncoord_out );

/* Check the work space and axis pointers can be used. */
      if( astOK ){

/* Now loop through every position, copying the axis values to the work array,
   normalising them using astNorm, and copying them back to the returned
   PointSet. */
         for( i = 0; i < npoint; i++ ){
            for( j = 0; j < ncoord_out; j++ ) work[ j ] = ptr_out[ j ][ i ];
            astNorm( cfr, work );
            for( j = 0; j < ncoord_out; j++ ) ptr_out[ j ][ i ] = work[ j ];
         }
      }

/* Free the work space. */
      work = (double *) astFree( (void *) work );

/* Annul the pointer to the Current Frame if it was obtained in this
   function. */
      if( !frm ) cfr = astAnnul( cfr );

   }

/* Clipping is only performed if the bounds of a clipping region are
   available for both axes. */
   if( this->clip_lbnd && this->clip_ubnd ){

/* Validate and translate the index of the clipping Frame. */
      iframe = astValidateFrameIndex( this, this->clip_frame, method );

/* Obtain a pointer to the clipping Frame and determine how many axes it
   has. */
      fr = astGetFrame( this, iframe );
      naxes = astGetNaxes( fr );

/* Report an error if the number of bounds does not equal the number of
   axes in the clipping Frame. */
      if( astOK && naxes != this->clip_axes ){
         astError( AST__CLPAX, "%s%s): The supplied %s specifies clipping "
                   "in %d dimensions, but the clipping Frame ('%s') has "
                   "%d axes.", status, method, class, class, this->clip_axes,
                   astGetTitle( fr ), naxes );
      }

/* Set a flag indicating if the coordinates in the clipping frame need to
   be normalised. */
      clip_norm = 1;

/* We now obtain a pointer to a PointSet holding the corresponding
   coordinates in the clipping frame.  If the clipping frame is the
   base frame, then take a clone of the PointSet holding base frame
   coordinates. */
      if( iframe == astGetBase( this ) ){
         if( forward ){
            clip = astClone( in );
         } else {
            clip = astClone( result );
         }

/* If the clipping frame is the current frame, then take a clone of the
   PointSet holding current coordinates. Note, if the returned physical
   coordinates have already been normalised, we don't need to normalise
   the clipping coordinates. */
      } else if( iframe == astGetCurrent( this ) ){
         if( forward ){
            clip = astClone( result );
            if( norm ) clip_norm = 0;
         } else {
            clip = astClone( in );
         }

/* If the clipping Frame is neither the base nor the current Frame, we need
   to map the returned normalised points into the clipping Frame. */
      } else {
         if( forward ){
            map = astGetMapping( this, AST__CURRENT, iframe );
         } else {
            map = astGetMapping( this, AST__BASE, iframe );
         }
         clip = astTransform( map, result, 1, NULL );
         map = astAnnul( map );
       }

/* Get a pointer to the coordinate data in the clipping Frame. */
      ptr_clip = astGetPoints( clip );

/* If necessary, normalise the coordinates in the clipping frame. */
      if( clip_norm ){

/* Get work space to hold a single position. */
         work = (double *) astMalloc( sizeof(double)*(size_t)naxes );

/* Check the work space and axis pointers can be used. */
         if( astOK ){

/* Now loop through every position, copying the axis values to the work array,
   normalising them using astNorm, and copying them back to the clipping
   PointSet. */
            for( i = 0; i < npoint; i++ ){
               for( j = 0; j < naxes; j++ ) work[ j ] = ptr_clip[ j ][ i ];
               astNorm( fr, work );
               for( j = 0; j < naxes; j++ ) ptr_clip[ j ][ i ] = work[ j ];
            }
         }

/* Free the work space. */
         work = (double *) astFree( (void *) work );

      }

/* If all has gone ok, we will now clip the returned points. */
      if( astOK ){

/* Get the logical operation to be used to determine if a point is to be
   clipped. A zero value means that a logical AND is to be performed
   between the axes (i.e. all axes must be within the supplied bounds for a
   point to be retained). A non-zero value means that a logical OR is to be
   performed between the axes (i.e. only a single axis need be within the
   supplied bounds for a point to be retained). */
         clip_or = astGetClipOp( this );

/* Do each point in turn. */
         for( j = 0; j < npoint; j++ ){

/* If all axes must fall within the supplied range to avoid the point being
   clipped (i.e. if clip_or is 0), then assume initially that the point
   is not to be clipped. This will be toggled as soon as the first
   out-of-bounds point is found. If, on the other hand, the point is
   only clipped if all axis values are out-of-bounds, then assume
   initially that the point is to be clipped. This will be toggled as
   soon as the first axis value is found which is not out-of-bounds. */
            clipit = clip_or;

/* Check each axis value for the current point. */
            for( i = 0; i < naxes; i++ ){
               axval =  ptr_clip[ i ][ j ];

/* Chekc that it is not bad. */
               if( axval != AST__BAD ){

/* Store the bounds of the clipping volume on this axis. */
                  lbnd = this->clip_lbnd[ i ];
                  ubnd = this->clip_ubnd[ i ];

/* Set a flag indicating if the axis value is within the specified range.
   If the supplied bounds are reversed, they specify the range to exclude,
   otherwise they specify the range to include.  */
                  if( lbnd <= ubnd ){
                     axin = ( axval >= lbnd && axval <= ubnd );
                  } else {
                     axin = ( axval < ubnd || axval > lbnd );
                  }

/* If the point is within the range and only one such point is
   required to avoid the point being clipped, indicate that the point
   should not be clipped, and leave the loop. */
                  if( axin && clip_or ){
                     clipit = 0;
                     break;

/* If the point is not within the range and we only one such point is
   required to cause the point to be clipped, indicate that the point
   should be clipped, and leave the loop. */
                  } else if( !axin && !clip_or ){
                     clipit = 1;
                     break;
                  }

/* Clip the point if any axis value is bad in the clipping Frame. */
               } else {
                  clipit = 1;
                  break;
               }

            }

/* If the point is to be clipped, set all returned axis values bad. */
            if( clipit ) {
               for( i = 0; i < naxes; i++ ) ptr_out[ i ][ j ] = AST__BAD;
            }

         }

      }

/* Annul the PointSet holding clipping Frame positions. */
      if( clip ) clip = astAnnul( clip );

/* Annul the clipping Frame pointer. */
      fr = astAnnul( fr );

    }

/* If an error has occurred, annul the result. */
   if( !astOK ) result = astAnnul( result );

/* Return a pointer to the output PointSet. */
   return result;

}

static AstPointSet *Transform( AstMapping *this, AstPointSet *in,
                               int forward, AstPointSet *out, int *status ) {
/*
*  Name:
*     Transform

*  Purpose:
*     Use a Plot to transform a set of points.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     AstPointSet *Transform( AstMapping *this, AstPointSet *in,
*                             int forward, AstPointSet *out )

*  Class Membership:
*     Plot member function (over-rides the astTransform protected
*     method inherited from the FrameSet class).

*  Description:
*     This function takes a Plot and a set of points encapsulated in a
*     PointSet and transforms the points from graphics coordinates to
*     physical coordinates (in the forward direction). If the returned
*     positions are physical coordinates (i.e. if a forward mapping is
*     performed) they are normalised using the astNorm method of the supplied
*     Plot. The returned axis values are set to AST__BAD for any positions
*     which are outside the clipping volume set up by the astClip method.

*  Parameters:
*     this
*        Pointer to the Plot.
*     in
*        Pointer to the PointSet holding the input coordinate data.
*     forward
*        A non-zero value indicates that the forward coordinate
*        transformation should be applied while a zero value requests the
*        inverse transformation.
*     out
*        Pointer to a PointSet which will hold the transformed (output)
*        coordinate values. A NULL value may also be given, in which case a
*        new PointSet will be created by this function.

*  Returned Value:
*     Pointer to the output (possibly new) PointSet.

*  Notes:
*     -  Clipping is only performed as set up using the astClip method.
*     In particular, the clipping specified by the arguments to the astPlot
*     constructor function is NOT performed. This is done in order to improve
*     the efficiency of the curve drawing method astGridLine.
*     -  A null pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*     -  The number of coordinate values per point in the input PointSet must
*     match the number of coordinates for the Plot being applied.
*     -  If an output PointSet is supplied, it must have space for sufficient
*     number of points and coordinate values per point to accommodate the
*     result. Any excess space will be ignored.
*/

/* Local Variables: */
   AstMapping *map;              /* Pointer to the mapping */
   AstPointSet *result;          /* Positions in output Frame */
   AstPlot *plot;                /* The Plot */

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* Get a pointer to the Plot. */
   plot = (AstPlot *) this;

/* Get the Mapping from the base to the current Frame. */
   map = astGetMapping( plot, AST__BASE, AST__CURRENT );

/* Do the transformation. */
   result = Trans( plot, NULL, map, in, forward, out, 1, "astTransform",
                   astGetClass( this ), status );

/* Annul the mapping. */
   map = astAnnul( map );

/* If an error has occurred, annul the result. */
   if( !astOK ) result = astAnnul( result );

/* Return a pointer to the output PointSet. */
   return result;

}

static double Typical( int n, double *value, double lolim, double hilim,
                       double *width, int *status ) {
/*
*  Name:
*     Typical

*  Purpose:
*     Return a typical value within the supplied array of values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     double Typical( int n, double *value, double lolim, double hilim,
*                     double *width, int *status  )

*  Class Membership:
*     Plot member function.

*  Description:
*     This function locates the approximate mode of the supplied values,
*     and returns one of the supplied values which is close to the modal
*     value. Values outside an indicated range are ignored.

*  Parameters:
*     n
*        The number of data values.
*     value
*        A pointer to an array of "n" values.
*     lolim
*        Values less than lolim are ignored. Supply as -DBL_MAX if there
*        is no lower limit.
*     hilim
*        Values greater than hilim are ignored. Supply as DBL_MAX if there
*        is no upper limit.
*     width
*        Pointer to a double in which to return the width (i,e, data range)
*        of the non-empty histogram cells. This is an estimate of the
*        range of used values in the supplied array. NULL may be supplied.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A typical value from the supplied array. AST__BAD is returned only
*     if an error has occurred, or if all the supplied values are AST__BAD
*     or outside the specified range.

*/

/* Local Variables: */
   double *a;             /* Pointer to next value */
   double cnt;            /* Modified count */
   double delta;          /* Bin size */
   double maxval;         /* Maximum supplied value */
   double mean;           /* Mean supplied value */
   double minval;         /* Minimum supplied value */
   double result;         /* The returned value. */
   double w0;             /* Rate of increase of weight with dist from edge */
   double w1;             /* Weight for left edge */
   double w2;             /* Weight for right edge */
   double w;              /* Weight for this bin */
   int *hist;             /* Pointer to first cell of histogram array */
   int i;                 /* Loop count */
   int ibin;              /* Bin index */
   int maxcnt;            /* Maximum no. of values in any bin */
   int modify;            /* Modify the effect of the edge bins? */
   int nbin;              /* No. of bins in histogram */
   int nc;                /* Total number of points in histogram */
   int ngood;             /* No. of good values supplied */
   int nonemp;            /* No. of non-empty bins in hstogram */

/* Initialise. */
   result = AST__BAD;
   if( width ) *width = 0.0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   ibin = 0;

/* Find the minimum and maximum value in the supplied array, which are
   also within the supplied limits. Also store the first good value
   encountered in "result". */
   minval = DBL_MAX;
   maxval = -DBL_MAX;
   a = value;
   ngood = 0;
   for( i = 0; i < n; i++, a++ ) {
      if( *a != AST__BAD ) {
         if( *a >= lolim && *a <= hilim ) {
            if( *a < minval ) minval = *a;
            if( *a > maxval ) maxval = *a;
            if( ngood == 0 ) result = *a;
            ngood++;
         }
      }
   }

/* Initialise the returned width to the total data range. */
   if( width && maxval != -DBL_MAX ) *width = maxval - minval;

/* If less than 3 points were found, we will return the first. Otherwise, if
   3 or more good values were found, find a typical value. */
   if( ngood > 2 ) {

/* We will form a histogram of the supplied values in order to find the
   mode. The number of bins in this histogram is chosen so that there
   is an average of 2 points per bin. Find the number of bins. */
      nbin = ( ngood + 1 )/2;

/* Find the bin size. If zero (i.e. if all values are equal), return the
   first good value established above. */
      delta = ( maxval - minval )/ nbin;
      if( delta > 0.0 ) {

/* Allocat ememory for the histogram. */
         hist = astMalloc( sizeof(int)*(size_t)nbin );
         if( hist ) {

/* Initialise the histogram. */
            for( i = 0; i < nbin; i++ ) hist[ i ] = 0;

/* Form the histogram. Form the mean data value at the same time. */
            mean = 0.0;
            a = value;
            nc = 0;
            for( i = 0; i < n; i++, a++ ){
               if( *a != AST__BAD ) {
                  if( *a >= lolim && *a <= hilim ) {
                     mean += *a;
                     ibin = (int) ( ( *a - minval )/ delta );
                     if( ibin == nbin ) ibin--;
                     hist[ ibin ]++;
                     nc++;
                  }
               }
            }

            mean /= ngood;

/* We tend to prefer not to use reference values which are very close the
   the limits since they can give problems with regard to normalization
   (rounding errors can knock them over the edge), so we modify the counts
   in each bin of the histogram to reduce the impact of bins near the edge.
   However, we do not do this if the number of bins is very small or if
   all the counts are in the edge bins. */
            modify = ( nbin > 4 &&
                      ( hist[ 0 ] + hist[ nbin - 1 ] < 0.98*ngood ) );

/* Find the bin with the highest modified count. If there is more than one bin
   with the highest modified count, choose the one which is closest to the
   mean data value found above. Also count the number of non-empty bins. */
            nonemp = 0;
            maxcnt = 0;
            w0 = nbin/2;
            for( i = 0; i < nbin; i++ ) {

               cnt = hist[ i ];
               if( cnt ) nonemp++;

               if( modify ) {
                  w1 = i*w0;
                  w2 = ( nbin - 1 - i )*w0;
                  w = ( w1 < w2 ) ? w1 :w2;
                  if( w < 1.0 ) cnt *= w;
               }

               if( cnt > maxcnt ) {
                  maxcnt = cnt;
                  ibin = i;

               } else if( cnt == maxcnt ) {
                  if( fabs( minval + ( i - 0.5 )*delta - mean ) <
                      fabs( minval + ( ibin - 0.5 )*delta - mean ) ) {
                     maxcnt = cnt;
                     ibin = i;
                  }
               }
            }

/* Free the histogram memory. */
            hist = astFree( hist );

/* If required, return the width of the non-empty bins. */
            if( width ) *width = nonemp*delta;

/* Call this function recursively to refine the value, restricting
   attention to those data values which are within the range of the bin
   found above. */
            if( maxcnt < nc && ibin*delta > 1000.0*DBL_EPSILON*fabs(maxval) ) {
               minval += ibin*delta;
               maxval = minval + delta;
               result = Typical( n, value, minval, maxval, NULL, status );
            }
         }
      }
   }

/* Return the result. */
   return result;
}

static int GetUseColour( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     GetUseColour

*  Purpose:
*     Get the Colour value to use for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GetUseColour( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This returns the Colour value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the colour
*     for the first set specific value is returned. For example, if the
*     Colour for AST__AXES_ID is requested, then the colour for AST__AXIS1_ID
*     will be returned if set, and otherwise the colour for AST__AXIS2_ID will
*     be returned. If AST__AXIS2_ID is not set either, then the default for
*     AST__AXIS2_ID will be returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Colour value to use.

*/

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return NOCOLOUR;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the value of the first
   set genuine identifier. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   if( nid > 1 ) {
      if(  astTestColour( this, id1 ) ) {
         id = id1;

      } else if(  nid > 1 && astTestColour( this, id2 ) ) {
         id = id2;

      } else if(  nid > 2 && astTestColour( this, id3 ) ) {
         id = id3;

      } else {
         id = id1;
      }
   }

/* Return the result. */
   return astGetColour( this, id );

}

static int GetUseFont( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     GetUseFont

*  Purpose:
*     Get the Font value to use for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GetUseFont( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This returns the Font value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the Font
*     for the first set specific value is returned. For example, if the
*     Font for AST__AXES_ID is requested, then the Font for AST__AXIS1_ID
*     will be returned if set, and otherwise the Font for AST__AXIS2_ID will
*     be returned. If AST__AXIS2_ID is not set either, then the default for
*     AST__AXIS2_ID will be returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Font value to use.

*/

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return NOFONT;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the value of the first set
   genuine identifier. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   if( nid > 1 ) {
      if(  astTestFont( this, id1 ) ) {
         id = id1;

      } else if(  nid > 1 && astTestFont( this, id2 ) ) {
         id = id2;

      } else if(  nid > 2 && astTestFont( this, id3 ) ) {
         id = id3;

      } else {
         id = id1;
      }
   }

/* Return the result. */
   return astGetFont( this, id );

}

static double GetUseSize( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     GetUseSize

*  Purpose:
*     Get the Size value to use for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     double GetUseSize( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This returns the Size value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the Size
*     for the first set specific value is returned. For example, if the
*     Size for AST__AXES_ID is requested, then the Size for AST__AXIS1_ID
*     will be returned if set, and otherwise the Size for AST__AXIS2_ID will
*     be returned. If AST__AXIS2_ID is not set either, then the default for
*     AXIS2_ID will be returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Size value to use.

*/

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return NOSIZE;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the value of the first set
   genuine identifier. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   if( nid > 1 ) {
      if(  astTestSize( this, id1 ) ) {
         id = id1;

      } else if(  nid > 1 && astTestSize( this, id2 ) ) {
         id = id2;

      } else if(  nid > 2 && astTestSize( this, id3 ) ) {
         id = id3;

      } else {
         id = id1;
      }
   }

/* Return the result. */
   return astGetSize( this, id );

}

static int GetUseStyle( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     GetUseStyle

*  Purpose:
*     Get the Style value to use for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int GetUseStyle( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This returns the Style value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the style
*     for the first set specific value is returned. For example, if the
*     Style for AST__AXES_ID is requested, then the style for AST__AXIS1_ID
*     will be returned if set, and otherwise the style for AST__AXIS2_ID will
*     be returned. If AST__AXIS2_ID is not set either, then the default for
*     AST__AXIS2_ID will be returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Style value to use.

*/

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return NOSTYLE;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the value of the first set
   genuine identifier. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   if( nid > 1 ) {
      if(  astTestStyle( this, id1 ) ) {
         id = id1;

      } else if(  nid > 1 && astTestStyle( this, id2 ) ) {
         id = id2;

      } else if(  nid > 2 && astTestStyle( this, id3 ) ) {
         id = id3;

      } else {
         id = id1;
      }
   }

/* Return the result. */
   return astGetStyle( this, id );

}

static double GetUseWidth( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     GetUseWidth

*  Purpose:
*     Get the Width value to use for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     double GetUseWidth( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This returns the Width value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the Width
*     for the first set specific value is returned. For example, if the
*     Width for AST__AXES_ID is requested, then the Width for AST__AXIS1_ID
*     will be returned if set, and otherwise the Width for AST__AXIS2_ID will
*     be returned. If AST__AXIS2_ID is not set either, then the default for
*     AST__AXIS2_ID will be returned.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Width value to use.

*/

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return NOWIDTH;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the value of the first set
   genuine identifier. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   if( nid > 1 ) {
      if(  astTestWidth( this, id1 ) ) {
         id = id1;

      } else if(  nid > 1 && astTestWidth( this, id2 ) ) {
         id = id2;

      } else if(  nid > 2 && astTestWidth( this, id3 ) ) {
         id = id3;

      } else {
         id = id1;
      }
   }

/* Return the result. */
   return astGetWidth( this, id );

}

static int TestUseColour( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     TestUseColour

*  Purpose:
*     Test the Colour value for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TestUseColour( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This tests the Colour value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the element
*     is considered to be set if all the corresponding specific values are
*     set.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Colour value state (1 if set, zero otherwise).

*/

/* Local Variables: */
   int ret;

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the logical AND of the
   test flags for the genuine identifiers. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   ret = astTestColour( this, id1 );
   if( nid > 1 ) ret = ret && astTestColour( this, id2 );
   if( nid > 2 ) ret = ret && astTestColour( this, id3 );

/* Return the result. */
   return ret;

}

static int TestUseFont( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     TestUseFont

*  Purpose:
*     Test the Font value for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TestUseFont( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This tests the Font value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the element
*     is considered to be set if all the corresponding specific values are
*     set.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Font value state (1 if set, zero otherwise).

*/

/* Local Variables: */
   int ret;

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the logical AND of the
   test flags for the genuine identifiers. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   ret = astTestFont( this, id1 );
   if( nid > 1 ) ret = ret && astTestFont( this, id2 );
   if( nid > 2 ) ret = ret && astTestFont( this, id3 );

/* Return the result. */
   return ret;

}

static int TestUseSize( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     TestUseSize

*  Purpose:
*     Test the Size value for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TestUseSize( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This tests the Size value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the element
*     is considered to be set if all the corresponding specific values are
*     set.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Size value state (1 if set, zero otherwise).

*/

/* Local Variables: */
   int ret;

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the logical AND of the
   test flags for the genuine identifiers. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   ret = astTestSize( this, id1 );
   if( nid > 1 ) ret = ret && astTestSize( this, id2 );
   if( nid > 2 ) ret = ret && astTestSize( this, id3 );

/* Return the result. */
   return ret;

}

static int TestUseStyle( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     TestUseStyle

*  Purpose:
*     Test the Style value for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TestUseStyle( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This tests the Style value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the element
*     is considered to be set if all the corresponding specific values are
*     set.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Style value state (1 if set, zero otherwise).

*/

/* Local Variables: */
   int ret;

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the logical AND of the
   test flags for the genuine identifiers. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   ret = astTestStyle( this, id1 );
   if( nid > 1 ) ret = ret && astTestStyle( this, id2 );
   if( nid > 2 ) ret = ret && astTestStyle( this, id3 );

/* Return the result. */
   return ret;

}

static int TestUseWidth( AstPlot *this, int id, int *status ) {
/*
*  Name:
*     TestUseWidth

*  Purpose:
*     Test the Width value for a specified graphical element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int TestUseWidth( AstPlot *this, int id, int *status )

*  Class Membership:
*     Plot member function.

*  Description:
*     This tests the Width value for the graphical element specified by
*     id. If an element related to a generic value is being accessed (e.g
*     "Axes" is generic, "Axis1" and "Axis2" are not), then the element
*     is considered to be set if all the corresponding specific values are
*     set.

*  Parameters:
*     this
*        Pointer to the Plot.
*     id
*        An integer specifying the graphical element to be drawn.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Width value state (1 if set, zero otherwise).

*/

/* Local Variables: */
   int ret;

/* Local Variables: */
   int id1;        /* First genuine identifier */
   int id2;        /* Second genuine identifier */
   int id3;        /* Third genuine identifier */
   int nid;        /* Number of genuine attributes */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* See if the supplied identifier is a psuedo-identifier representing two
   or three other genuine identifiers. If so, return the logical AND of the
   test flags for the genuine identifiers. */
   nid = IdFind( id, astGetNin( this ), &id1, &id2, &id3, status );
   ret = astTestWidth( this, id1 );
   if( nid > 1 ) ret = ret && astTestWidth( this, id2 );
   if( nid > 2 ) ret = ret && astTestWidth( this, id3 );

/* Return the result. */
   return ret;

}

static int ToggleLogLin( AstPlot *this, int axis, int islog,
                         const char *method, int *status ){
/*
*
*  Name:
*     ToggleLogLin

*  Purpose:
*     Toggle the nature of the Plot axis mapping.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int ToggleLogLin( AstPlot *this, int axis, int islog,
*                       const char *method, int *status )

*  Class Membership:
*     Plot member function

*  Description:
*     Each axis in the graphics Frame of a Plot can be mapped linearly or
*     logarithmically onto the corresponding axis in the base Frame of
*     the FrameSet supplied whtn the Plot was constructed. This function
*     toggles the nature of the specified axis; if it is currently
*     logarithmic it becomes linear, and if it is linear it becomes
*     logarithmic.
*
*     If the Frame canot be re-maped (for instance because the visible
*     part of the axis includes the value zero), then zero is returned
*     but no error is reported.

*  Parameters:
*     this
*        The Plot.
*     axis
*        Zero based axis index.
*     islog
*        Is the axis currently logarithmic? If so, this function remaps
*        it so that it is linear (and vice-versa).
*     method
*        Pointer to a null-terminated string holding the name of the calling
*        method (only used within error mesages).
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Non-zero if the attempt to re-map the graphics Frame was succesful,
*     zero otherwise.

*/

/* Local Variables: */
   AstCmpMap *remap1;   /* 1D Mapping to re-map the graphics Frame */
   AstCmpMap *remap2;   /* 2D Mapping to re-map the graphics Frame */
   AstMathMap *logmap;  /* 1D Logarithmic axis Mapping */
   AstUnitMap *unitmap;  /* 1D Unit mapping */
   AstWinMap *linmap;   /* 1D Linear axis Mapping */
   char fwdexp[ 25 + 2*AST__DBL_WIDTH ];  /* Forward log mapping expression */
   char invexp[ 28 + 2*AST__DBL_WIDTH ];  /* Inverse log mapping expression */
   const char *fwd[1];  /* Pointer to pass to MathMap constructor */
   const char *inv[1];  /* Pointer to pass to MathMap constructor */
   double a;            /* Constant for log expression */
   double b1;           /* Original base Frame axis value at first edge */
   double b2;           /* Original base Frame axis value at second edge */
   double b;            /* Constant for log expression */
   double c;            /* Constant for log expression */
   double g1;           /* Graphics axis value at first edge */
   double g2;           /* Graphics axis value at second edge */
   int result;          /* Returned value */

/* Inotialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get the corresponding axis limits in the graphics coordinate system
   and the original base Frame coordinate system. */
   if( axis == 0 ) {
      if( this->xrev ) {
         g1 = this->xhi;
         g2 = this->xlo;
      } else {
         g1 = this->xlo;
         g2 = this->xhi;
      }
      b1 = this->bbox[ 0 ];
      b2 = this->bbox[ 2 ];

   } else {
      if( this->yrev ) {
         g1 = this->yhi;
         g2 = this->ylo;
      } else {
         g1 = this->ylo;
         g2 = this->yhi;
      }
      b1 = this->bbox[ 1 ];
      b2 = this->bbox[ 3 ];
   }

/* Check the limits are usable (e.g. the base Frame values will be bad
   if this Plot was restored from a dump of a Plot created before the
   LogPlot attributes were added). */
   if( b1 != AST__BAD && b2 != AST__BAD && g1 != g2 && b1 != b2 &&
       b1*b2 > 0.0 ) {

/* Form the 1D Mapping which maps the specified axis linearly onto the plotting
   surface. The forward transformation goes from graphics to base Frame. */
      linmap = astWinMap( 1, &g1, &g2, &b1, &b2, "", status );

/* Form the 1D Mapping which maps the specified axis logarithmically onto the
   plotting surface. The forward transformation goes from graphics to base
   Frame. */
      c = log10( b1/b2 );
      a = ( g1 - g2 )/c;

      if( b1 > 0.0 ) {
         b = ( g2*log10( b1 ) - g1*log10( b2 ) )/c;
         (void) sprintf( invexp, "g=%.*g*log10(b)+%.*g", AST__DBL_DIG, a, AST__DBL_DIG, b );
         (void) sprintf( fwdexp, "b=pow(10,(g-%.*g)/%.*g)", AST__DBL_DIG, b, AST__DBL_DIG, a );

      } else {
         b = ( g2*log10( -b1 ) - g1*log10( -b2 ) )/c;
         (void) sprintf( invexp, "g=%.*g*log10(-b)+%.*g", AST__DBL_DIG, a, AST__DBL_DIG, b );
         (void) sprintf( fwdexp, "b=-pow(10,(g-%.*g)/%.*g)", AST__DBL_DIG, b, AST__DBL_DIG, a );
      }

      fwd[ 0 ] = (const char *) fwdexp;
      inv[ 0 ] = (const char *) invexp;
      logmap = astMathMap( 1, 1, 1, fwd, 1, inv, "SimpFI=1,SimpIF=1", status );

/* If the axis was previously logarithmic, get the Mapping with which to remap
   the graphics Frame so that it becomes linearly related to the base Frame
   in the FrameSet supplied when the Plot was constructed. */
      if( islog ) {
         astInvert( linmap );
         remap1 = astCmpMap( logmap, linmap, 1, "", status );

/* If the axis was previously linear, store the new value and get the Mapping
   with which to remap the graphics Frame so that it becomes logarithmically
   related to the base Frame in the FrameSet supplied when the Plot was
   constructed. */
      } else {
         astInvert( logmap );
         remap1 = astCmpMap( linmap, logmap, 1, "", status );
      }

/* Add a 1D UnitMap to map the unaltered mapping. */
      unitmap = astUnitMap( 1, "", status );
      if( axis == 0 ) {
         remap2 = astCmpMap( remap1, unitmap, 0, "", status );
      } else {
         remap2 = astCmpMap( unitmap, remap1, 0, "", status );
      }

/* Remap the base (graphics) Frame in the Plot. */
      astRemapFrame( this, AST__BASE, remap2 );

/* Free resources. */
      remap1 = astAnnul( remap1 );
      remap2 = astAnnul( remap2 );
      logmap = astAnnul( logmap );
      linmap = astAnnul( linmap );
      unitmap = astAnnul( unitmap );

/* Indicate success. */
      if( astOK ) result = 1;

   }

/* Return the result. */
   return result;
}

static int Ustrcmp( const char *a, const char *b, int *status ){
/*
*  Name:
*     Ustrncmp

*  Purpose:
*     A case blind version of strcmp.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Ustrcmp( const char *a, const char *b )

*  Class Membership:
*     Plot member function.

*  Description:
*     Returns 0 if there are no differences between the two strings, and 1
*     otherwise. Comparisons are case blind.

*  Parameters:
*     a
*        Pointer to first string.
*     b
*        Pointer to second string.

*  Returned Value:
*     Zero if the strings match, otherwise one.

*  Notes:
*     -  This function does not consider the sign of the difference between
*     the two strings, whereas "strcmp" does.
*     -  This function attempts to execute even if an error has occurred.

*/

/* Local Variables: */
   const char *aa;         /* Pointer to next "a" character */
   const char *bb;         /* Pointer to next "b" character */
   int ret;                /* Returned value */

/* Initialise the returned value to indicate that the strings match. */
   ret = 0;

/* Initialise pointers to the start of each string. */
   aa = a;
   bb = b;

/* Loop round each character. */
   while( 1 ){

/* We leave the loop if either of the strings has been exhausted. */
      if( !(*aa ) || !(*bb) ){

/* If one of the strings has not been exhausted, indicate that the
   strings are different. */
         if( *aa || *bb ) ret = 1;

/* Break out of the loop. */
         break;

/* If neither string has been exhausted, convert the next characters to
   upper case and compare them, incrementing the pointers to the next
   characters at the same time. If they are different, break out of the
   loop. */
      } else {

         if( toupper( (int) *(aa++) ) != toupper( (int) *(bb++) ) ){
            ret = 1;
            break;
         }

      }

   }

/* Return the result. */
   return ret;

}

static int Ustrncmp( const char *a, const char *b, size_t n, int *status ){
/*
*  Name:
*     Ustrncmp

*  Purpose:
*     A case blind version of strncmp.

*  Type:
*     Private function.

*  Synopsis:
*     #include "plot.h"
*     int Ustrncmp( const char *a, const char *b, size_t n )

*  Class Membership:
*     Plot member function.

*  Description:
*     Returns 0 if there are no differences between the first "n"
*     characters of the two strings, and 1 otherwise. Comparisons are
*     case blind.

*  Parameters:
*     a
*        Pointer to first string.
*     b
*        Pointer to second string.
*     n
*        The maximum number of characters to compare.

*  Returned Value:
*     Zero if the strings match, otherwise one.

*  Notes:
*     -  This function does not consider the sign of the difference
*     between the two strings, whereas "strncmp" does.
*     -  This function attempts to execute even if an error has
*     occurred.

*/

/* Local Variables: */
   const char *aa;         /* Pointer to next "a" character */
   const char *bb;         /* Pointer to next "b" character */
   int i;                  /* Character index */
   int ret;                /* Returned value */

/* Initialise the returned value to indicate that the strings match. */
   ret = 0;

/* Initialise pointers to the start of each string. */
   aa = a;
   bb = b;

/* Compare up to "n" characters. */
   for( i = 0; i < (int) n; i++ ){

/* We leave the loop if either of the strings has been exhausted. */
      if( !(*aa ) || !(*bb) ){

/* If one of the strings has not been exhausted, indicate that the
   strings are different. */
         if( *aa || *bb ) ret = 1;

/* Break out of the loop. */
         break;

/* If neither string has been exhausted, convert the next characters to
   upper case and compare them, incrementing the pointers to the next
   characters at the same time. If they are different, break out of the
   loop. */
      } else {

         if( toupper( (int) *(aa++) ) != toupper( (int) *(bb++) ) ){
            ret = 1;
            break;
         }

      }

   }

/* Return the result. */
   return ret;

}

/* Destructor. */
/* ----------- */
static void Delete( AstObject *obj, int *status ) {
/*
*  Name:
*     Delete

*  Purpose:
*     Destructor for Plot objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Delete( AstObject *obj, int *status )

*  Description:
*     This function implements the destructor for Plot objects.

*  Parameters:
*     obj
*        Pointer to the object to be deleted.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     This function attempts to execute even if the global error status is
*     set.
*/

/* Local Variables: */
   AstPlot *this;               /* Pointer to Plot */
   int i;

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) obj;

/* Free the clipping bounds arrays. */
   this->clip_lbnd = (double *) astFree( (void *) this->clip_lbnd );
   this->clip_ubnd = (double *) astFree( (void *) this->clip_ubnd );

/* Free the Grf function stack */
   this->grfstack = (AstGrfPtrs *) astFree( (void *) this->grfstack );

/* Free the graphics attribute stack. */
   for( i = this->ngat - 1; i >= 0; i-- ) {
     this->gat[ i ] = astFree( this->gat[ i ] );
   }

/* Free the graphics context pointer. */
   if( this->grfcontext ) {
      this->grfcontext = astAnnul( this->grfcontext );
      this->grfcontextID = astAnnulId( this->grfcontextID );
   }

/* Free the information about the tick marks to draw. */
   for( i = 0; i < 3; i++ ) {
      this->majtickval[ i ] = astFree( this->majtickval[ i ] );
      this->mintickval[ i ] = astFree( this->mintickval[ i ] );
      this->nmajtickval[ i ] = 0;
      this->nmintickval[ i ] = 0;
   }

/* Free the information about the drawn tick marks. */
   SaveTick( this, -1, 0.0, 0.0, 0, status );
}

/* Copy constructor. */
/* ----------------- */
static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
/*
*  Name:
*     Copy

*  Purpose:
*     Copy constructor for Plot objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Copy( const AstObject *objin, AstObject *objout, int *status )

*  Description:
*     This function implements the copy constructor for Plot objects.

*  Parameters:
*     objin
*        Pointer to the object to be copied.
*     objout
*        Pointer to the object being constructed.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     -  This constructor makes a deep copy.
*/

/* Local Variables: */
   AstPlot *in;                 /* Pointer to input Plot */
   AstPlot *out;                /* Pointer to output Plot */
   int axis;                    /* Zero based axis index */
   int n;                       /* Number of ticks saved */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain pointers to the input and output Plots. */
   in = (AstPlot *) objin;
   out = (AstPlot *) objout;

/* For safety, first clear any references to the input memory from
   the output Plot. */
   out->clip_lbnd = NULL;
   out->clip_ubnd = NULL;
   out->gat = NULL;
   out->ngat = 0;

   for( axis = 0; axis < 3; axis++ ) {
      out->majtickgx[ axis ] = NULL;
      out->majtickgy[ axis ] = NULL;
      out->majtickcount[ axis ] = 0;
      out->mintickgx[ axis ] = NULL;
      out->mintickgy[ axis ] = NULL;
      out->mintickcount[ axis ] = 0;
      out->majtickval[ axis ] = NULL;
      out->nmajtickval[ axis ] = 0;
      out->mintickval[ axis ] = NULL;
      out->nmintickval[ axis ] = 0;
   }

/* Copy the clipping bounds arrays. */
   out->clip_lbnd = (double *) astStore( NULL, (void *) in->clip_lbnd,
                                      sizeof(double)*(size_t)(in->clip_axes) );
   out->clip_ubnd = (double *) astStore( NULL, (void *) in->clip_ubnd,
                                      sizeof(double)*(size_t)(in->clip_axes) );

/* Copy the Grf function stack */
   out->grfstack = (AstGrfPtrs *) astStore( NULL, (void *) in->grfstack,
                                  sizeof(AstGrfPtrs)*(size_t)(in->grfnstack ));

/* Copy the information about drawn tick marks. */
   for( axis = 0; axis < 3; axis++ ) {
      n = in->majtickcount[ axis ];
      out->majtickgx[ axis ] = (double *) astStore( NULL, in->majtickgx[ axis ],
                                                    n*sizeof( double ) );
      out->majtickgy[ axis ] = (double *) astStore( NULL, in->majtickgy[ axis ],
                                                    n*sizeof( double ) );
      out->majtickcount[ axis ] = n;

      n = in->mintickcount[ axis ];
      out->mintickgx[ axis ] = (double *) astStore( NULL, in->mintickgx[ axis ],
                                                    n*sizeof( double ) );
      out->mintickgy[ axis ] = (double *) astStore( NULL, in->mintickgy[ axis ],
                                                    n*sizeof( double ) );
      out->mintickcount[ axis ] = n;

      n = in->nmajtickval[ axis ];
      out->majtickval[ axis ] = (double *) astStore( NULL, in->majtickval[ axis ],
                                                     n*sizeof( double ) );
      out->nmajtickval[ axis ] = n;

      n = in->nmintickval[ axis ];
      out->mintickval[ axis ] = (double *) astStore( NULL, in->mintickval[ axis ],
                                                     n*sizeof( double ) );
      out->nmintickval[ axis ] = n;
   }

/* If an error occurred, free any allocated memory. */
   if ( !astOK ) {
      out->clip_lbnd = (double *) astFree( out->clip_lbnd );
      out->clip_ubnd = (double *) astFree( out->clip_ubnd );
      out->grfstack = (AstGrfPtrs *) astFree( out->grfstack );
      SaveTick( out, -1, 0.0, 0.0, 0, status );
    }
}

/* Dump function. */
/* -------------- */
static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
/*
*  Name:
*     Dump

*  Purpose:
*     Dump function for Plot objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Dump( AstObject *this, AstChannel *channel, int *status )

*  Description:
*     This function implements the Dump function which writes out data
*     for the Plot class to an output Channel.

*  Parameters:
*     this
*        Pointer to the Plot whose data are being written.
*     channel
*        Pointer to the Channel to which the data are being written.
*     status
*        Pointer to the inherited status variable.
*/

#define KEY_LEN 50               /* Maximum length of a keyword */

/* Local Variables: */
   AstPlot *this;                /* Pointer to the Plot structure */
   char buff[ KEY_LEN + 1 ];     /* Buffer for keyword string */
   char *comment;                /* Pointer to comment string */
   double dval;                  /* Double precision value */
   int ax;                       /* Axis to which element refers */
   int axis;                     /* Zero based axis index */
   int id;                       /* Zero based graphical object id */
   int ival;                     /* Integer value */
   int itick;                    /* Tick mark index */
   int nax;                      /* Number of base Frame axes */
   int set;                      /* Attribute value set? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the Plot structure. */
   this = (AstPlot *) this_object;

/* Get the number of graphics (base) frame axes - 2 for a Plot, 3 for a
   Plot3D. */
   nax = astGetNin( this );

/* Write out values representing the instance variables for the
   Plot class.  Accompany these with appropriate comment strings,
   possibly depending on the values being written.*/

/* In the case of attributes, we first use the appropriate (private)
   Test...  member function to see if they are set. If so, we then use
   the (private) Get... function to obtain the value to be written
   out.

   For attributes which are not set, we use the astGet... method to
   obtain the value instead. This will supply a default value
   (possibly provided by a derived class which over-rides this method)
   which is more useful to a human reader as it corresponds to the
   actual default attribute value.  Since "set" will be zero, these
   values are for information only and will not be read back. */

/* Tol. */
/* ---- */
   set = TestTol( this, status );
   dval = set ? GetTol( this, status ) : astGetTol( this );
   astWriteDouble( channel, "Tol", set, 0, dval, "Plotting tolerance" );

/* Grid. */
/* ----- */
   set = TestGrid( this, status );
   ival = set ? GetGrid( this, status ) : astGetGrid( this );
   astWriteInt( channel, "Grid", set, 0, ival, "Is a grid required?" );

/* TickAll. */
/* -------- */
   set = TestTickAll( this, status );
   ival = set ? GetTickAll( this, status ) : astGetTickAll( this );
   astWriteInt( channel, "TckAll", set, 1, ival, "Put ticks on all edges?" );

/* ForceExterior. */
/* -------------- */
   set = TestForceExterior( this, status );
   ival = set ? GetForceExterior( this, status ) : astGetForceExterior( this );
   astWriteInt( channel, "FrcExt", set, 1, ival, "Force exterior labelling?" );

/* Invisible. */
/* ---------- */
   set = TestInvisible( this, status );
   ival = set ? GetInvisible( this, status ) : astGetInvisible( this );
   astWriteInt( channel, "Invsbl", set, 1, ival, "Use invisible ink?" );

/* Border. */
/* ------- */
   set = TestBorder( this, status );
   ival = set ? GetBorder( this, status ) : astGetBorder( this );
   astWriteInt( channel, "Border", set, 0, ival, "Draw a border round the grid?" );

/* ClipOp. */
/* ------- */
   set = TestClipOp( this, status );
   ival = set ? GetClipOp( this, status ) : astGetClipOp( this );
   astWriteInt( channel, "ClpOp", set, 0, ival, "Clip using logical OR?" );

/* Clip. */
/* ----- */
   set = TestClip( this, status );
   ival = set ? GetClip( this, status ) : astGetClip( this );
   astWriteInt( channel, "Clip", set, 0, ival,
                ((ival == 0)?"Do not clip at plot edges":
                ((ival == 1)?"Clip curves at plot edges":
                ((ival == 2)?"Clip markers at plot edges":
                             "Clip markers and curves at plot edges"))));

/* DrawTitle. */
/* --------- */
   set = TestDrawTitle( this, status );
   ival = set ? GetDrawTitle( this, status ) : astGetDrawTitle( this );
   astWriteInt( channel, "DrwTtl", set, 1, ival, "Add a title to the grid?" );

/* DrawAxesUnits(axis). */
/* ----------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestDrawAxes( this, axis, status );
      ival = set ? GetDrawAxes( this, axis, status ) : astGetDrawAxes( this, axis );
      (void) sprintf( buff, "DrwAxs%d", axis + 1 );
      astWriteInt( channel, buff, set, 0, ival, "Draw axis through ticks?" );
   }

/* Abbrev(axis). */
/* ------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestAbbrev( this, axis, status );
      ival = set ? GetAbbrev( this, axis, status ) : astGetAbbrev( this, axis );
      (void) sprintf( buff, "Abbrv%d", axis + 1 );
      astWriteInt( channel, buff, set, 0, ival, "Abbreviate numerical axis labels?" );
   }

/* Escape. */
/* ------- */
   set = TestEscape( this, status );
   ival = set ? GetEscape( this, status ) : astGetEscape( this );
   astWriteInt( channel, "Escape", set, 1, ival, "Interpret escape sequences?" );

/* LabelAt(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestLabelAt( this, axis, status );
      dval = set ? GetLabelAt( this, axis, status ) : astGetLabelAt( this, axis );
      if( dval != AST__BAD ){
         (void) sprintf( buff, "LblAt%d", axis + 1 );
         astWriteDouble( channel, buff, set, 0, dval, "Put numerical labels at" );
      }
   }

/* Centre(axis). */
/* ------------ */
   for( axis = 0; axis < nax; axis++ ){
      set = TestCentre( this, axis, status );
      dval = set ? GetCentre( this, axis, status ) : astGetCentre( this, axis );
      if( dval != AST__BAD ){
         (void) sprintf( buff, "Cen%d", axis + 1 );
         astWriteDouble( channel, buff, set, 0, dval, "Tick mark origin" );
      }
   }

/* Gap(axis). */
/* ---------- */
/* Discovering the default value requires a lot of calculation. Only
   write out this attribute if an explicit value has been set. */
   for( axis = 0; axis < nax; axis++ ){
      if( astTestGap( this, axis ) ) {
         dval = astGetGap( this, axis );
         if( dval != AST__BAD ){
            (void) sprintf( buff, "Gap%d", axis + 1 );
            astWriteDouble( channel, buff, set, 0, dval, "Difference between ticks" );
         }
      }
   }

/* LogGap(axis). */
/* ------------- */
/* Discovering the default value requires a lot of calculation. Only
   write out this attribute if an explicit value has been set. */
   for( axis = 0; axis < nax; axis++ ){
      if( astTestLogGap( this, axis ) ) {
         dval = astGetLogGap( this, axis );
         if( dval != AST__BAD ){
            (void) sprintf( buff, "LgGap%d", axis + 1 );
            astWriteDouble( channel, buff, set, 0, dval, "Ratio between ticks" );
         }
      }
   }

/* NumLabGap(axis). */
/* ---------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestNumLabGap( this, axis, status );
      dval = set ? GetNumLabGap( this, axis, status ) : astGetNumLabGap( this, axis );
      if( dval != AST__BAD ) {
         (void) sprintf( buff, "NmGap%d", axis + 1 );
         astWriteDouble( channel, buff, set, 1, dval, "Spacing of numerical labels" );
      }
   }

/* TextLabGap(axis). */
/* ----------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestTextLabGap( this, axis, status );
      dval = set ? GetTextLabGap( this, axis, status ) : astGetTextLabGap( this, axis );
      if( dval != AST__BAD ) {
         (void) sprintf( buff, "TxGap%d", axis + 1 );
         astWriteDouble( channel, buff, set, 1, dval, "Spacing of descriptive labels" );
      }
   }

/* LabelUp(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestLabelUp( this, axis, status );
      ival = set ? GetLabelUp( this, axis, status ) : astGetLabelUp( this, axis );
      (void) sprintf( buff, "LblUp%d", axis + 1 );
      astWriteInt( channel, buff, set, 1, ival, "Draw numerical labels upright?" );
   }

/* LogPlot(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestLogPlot( this, axis, status );
      ival = set ? GetLogPlot( this, axis, status ) : astGetLogPlot( this, axis );
      (void) sprintf( buff, "LgPlt%d", axis + 1 );
      astWriteInt( channel, buff, set, 1, ival, "Map plot axis logarithmically?" );
   }

/* LogTicks(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestLogTicks( this, axis, status );
      ival = set ? GetLogTicks( this, axis, status ) : astGetLogTicks( this, axis );
      (void) sprintf( buff, "LgTck%d", axis + 1 );
      astWriteInt( channel, buff, set, 1, ival, "Space ticks logarithmically?" );
   }

/* LogLabel(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestLogLabel( this, axis, status );
      ival = set ? GetLogLabel( this, axis, status ) : astGetLogLabel( this, axis );
      (void) sprintf( buff, "LgLbl%d", axis + 1 );
      astWriteInt( channel, buff, set, 1, ival, "Scientific notation for labels?" );
   }

/* NumLab(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestNumLab( this, axis, status );
      ival = set ? GetNumLab( this, axis, status ) : astGetNumLab( this, axis );
      (void) sprintf( buff, "NmLbl%d", axis + 1 );
      astWriteInt( channel, buff, set, 1, ival, "Draw numerical labels?" );
   }

/* MinTick(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestMinTick( this, axis, status );
      ival = set ? GetMinTick( this, axis, status ) : astGetMinTick( this, axis );
      (void) sprintf( buff, "MnTks%d", axis + 1 );
      astWriteInt( channel, buff, set, 0, ival, "No. of sub-divisions "
                   "between major tick marks" );
   }

/* TextLab(axis). */
/* -------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestTextLab( this, axis, status );
      ival = set ? GetTextLab( this, axis, status ) : astGetTextLab( this, axis );
      (void) sprintf( buff, "TxLbl%d", axis + 1 );
      astWriteInt( channel, buff, set, 0, ival, "Draw textual label?" );
   }

/* LabelUnits(axis). */
/* ----------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestLabelUnits( this, axis, status );
      ival = set ? GetLabelUnits( this, axis, status ) : astGetLabelUnits( this, axis );
      (void) sprintf( buff, "LbUnt%d", axis + 1 );
      astWriteInt( channel, buff, set, 0, ival, "Add units to axis label?" );
   }

/* Style(object). */
/* -------------- */
   for( id = 0; id < AST__NPID; id++ ){
      set = TestStyle( this, id, status );
      ival = set ? GetStyle( this, id, status ) : astGetStyle( this, id );
      (void) sprintf( buff, "Style%d", id + 1 );
      comment = GrfItem( id, " line style", &ax, status );
      if( ax < nax ) astWriteInt( channel, buff, set, 0, ival, comment );
      comment = (char *) astFree( (void *) comment );
   }

/* Font(object). */
/* ------------- */
   for( id = 0; id < AST__NPID; id++ ){
      set = TestFont( this, id, status );
      ival = set ? GetFont( this, id, status ) : astGetFont( this, id );
      (void) sprintf( buff, "Font%d", id + 1 );
      comment = GrfItem( id, " character font", &ax, status );
      if( ax < nax ) astWriteInt( channel, buff, set, 0, ival, comment );
      comment = (char *) astFree( (void *) comment );
   }

/* Colour(object). */
/* --------------- */
   for( id = 0; id < AST__NPID; id++ ){
      set = TestColour( this, id, status );
      ival = set ? GetColour( this, id, status ) : astGetColour( this, id );
      (void) sprintf( buff, "Col%d", id + 1 );
      comment = GrfItem( id, " colour index", &ax, status );
      if( ax < nax ) astWriteInt( channel, buff, set, 0, ival, comment );
      comment = (char *) astFree( (void *) comment );
   }

/* Width(object). */
/* -------------- */
   for( id = 0; id < AST__NPID; id++ ){
      set = TestWidth( this, id, status );
      dval = set ? GetWidth( this, id, status ) : astGetWidth( this, id );
      if( dval != AST__BAD ) {
         (void) sprintf( buff, "Width%d", id + 1 );
         comment = GrfItem( id, " line width", &ax, status );
         if( ax < nax ) astWriteDouble( channel, buff, set, 0, dval, comment );
         comment = (char *) astFree( (void *) comment );
      }
   }

/* Size(object). */
/* ------------- */
   for( id = 0; id < AST__NPID; id++ ){
      set = TestSize( this, id, status );
      dval = set ? GetSize( this, id, status ) : astGetSize( this, id );
      if( dval != AST__BAD ) {
         (void) sprintf( buff, "Size%d", id + 1 );
         comment = GrfItem( id, " character size", &ax, status );
         if( ax < nax ) astWriteDouble( channel, buff, set, 0, dval, comment );
         comment = (char *) astFree( (void *) comment );
      }
   }

/* TitleGap. */
/* --------- */
   set = TestTitleGap( this, status );
   dval = set ? GetTitleGap( this, status ) : astGetTitleGap( this );
   if( dval != AST__BAD ) astWriteDouble( channel, "TtlGap", set, 1, dval,
                                         "Gap between title and edge" );

/* MajTickLen(axis). */
/* ----------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestMajTickLen( this, axis, status );
      dval = set ? GetMajTickLen( this, axis, status ) : astGetMajTickLen( this, axis );
      if( dval != AST__BAD ) {
         (void) sprintf( buff, "MjTkLn%d", axis + 1 );
         astWriteDouble( channel, buff, set, 0, dval, "Major tick length" );
      }
   }

/* MinTickLen(axis). */
/* ----------------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestMinTickLen( this, axis, status );
      dval = set ? GetMinTickLen( this, axis, status ) : astGetMinTickLen( this, axis );
      if( dval != AST__BAD ) {
         (void) sprintf( buff, "MnTkLn%d", axis + 1 );
         astWriteDouble( channel, buff, set, 1, dval, "Minor tick length" );
      }
   }

/* Labelling. */
/* ---------- */
   set = TestLabelling( this, status );
   ival = set ? GetLabelling( this, status ) : astGetLabelling( this );
   comment = "Labelling scheme";
   astWriteString( channel, "Lbling", set, 0, xlbling[ival], comment );

/* TextGapType. */
/* ------------ */
   set = TestTextGapType( this, status );
   ival = set ? GetTextGapType( this, status ) : astGetTextGapType( this );
   comment = "Text gap reference position";
   astWriteString( channel, "TGapTyp", set, 0, xtgaptype[ival], comment );

/* Edge(axis). */
/* ----------- */
   for( axis = 0; axis < nax; axis++ ){
      set = TestEdge( this, axis, status );
      ival = set ? GetEdge( this, axis, status ) : astGetEdge( this, axis );
      (void) sprintf( buff, "Edge%d", axis + 1 );
      comment = "Edge used to label an axis";
      astWriteString( channel, buff, set, 0, xedge[ival], comment );
   }

/* Now do instance variables which are not attributes. */
/* =================================================== */

/* Only write out clipping information if set. */
   if( this->clip_lbnd && this->clip_ubnd ){

/* The lower bounds of the clipping volume. */
      for( axis = 0; axis < this->clip_axes; axis++ ){
         (void) sprintf( buff, "ClpLb%d", axis + 1 );
         if( this->clip_lbnd && (this->clip_lbnd)[ axis ] != AST__BAD ){
            astWriteDouble( channel, buff, 1, 0, (this->clip_lbnd)[ axis ],
                            "Lower bound of clipping region" );
         }
      }

/* The upper bounds of the clipping volume. */
      for( axis = 0; axis < this->clip_axes; axis++ ){
         (void) sprintf( buff, "ClpUb%d", axis + 1 );
         if( this->clip_ubnd && (this->clip_ubnd)[ axis ] != AST__BAD ){
            astWriteDouble( channel, buff, 1, 0, (this->clip_ubnd)[ axis ],
                            "Upper bound of clipping region" );
         }
      }

/* The number of bounds supplied for the clipping volume. */
      astWriteInt( channel, "ClpAxs", 1, 0, this->clip_axes,
                   "No. of bounds for clipping region" );

/* The index of the clipping Frame within the Plot. */
      astWriteInt( channel, "ClpFrm", 1, 0, this->clip_frame,
                   "Index of clipping Frame" );
   }

/* The bounds of the plotting area in graphics coords. */
   astWriteDouble( channel, "Xlo", 1, 1, this->xlo,
                   "Lower X bound of plotting area" );
   astWriteDouble( channel, "Ylo", 1, 1, this->ylo,
                   "Lower Y bound of plotting area" );
   astWriteDouble( channel, "Xhi", 1, 1, this->xhi,
                   "Upper X bound of plotting area" );
   astWriteDouble( channel, "Yhi", 1, 1, this->yhi,
                   "Upper Y bound of plotting area" );

/* Axis reversal flags. */
   astWriteInt( channel, "Xrev", 1, 0, this->xrev, "X axis reversed?" );
   astWriteInt( channel, "Yrev", 1, 0, this->yrev, "Y axis reversed?" );

/* The bounds of the plotting area in the base Frame of the FrameSet
   supplied when the Plot was constructed. */
   astWriteDouble( channel, "Xb1", 1, 1, this->bbox[ 0 ],
                   "Lower X bound of supplied base Frame" );
   astWriteDouble( channel, "Yb1", 1, 1, this->bbox[ 1 ],
                   "Lower Y bound of supplied base Frame" );
   astWriteDouble( channel, "Xb2", 1, 1, this->bbox[ 2 ],
                   "Upper X bound of supplied base Frame" );
   astWriteDouble( channel, "Yb2", 1, 1, this->bbox[ 3 ],
                   "Upper Y bound of supplied base Frame" );

/* User-specified tick values */
   for( axis = 0; axis < 3; axis++ ) {

      if( this->nmajtickval[ axis ] > 0 ) {
         sprintf( buff, "NMjTk%d", axis + 1 );
         astWriteInt( channel, buff, 1, 1, this->nmajtickval[ axis ], "" );

         for( itick = 0; itick < this->nmajtickval[ axis ]; itick++ ) {
            sprintf( buff, "MjTk%d_%d", axis + 1, itick + 1 );
            astWriteDouble( channel, buff, 1, 1,
                            this->majtickval[ axis ][ itick ], "" );
         }
      }

      if( this->nmintickval[ axis ] > 0 ) {
         sprintf( buff, "NMnTk%d", axis + 1 );
         astWriteInt( channel, buff, 1, 1, this->nmintickval[ axis ], "" );

         for( itick = 0; itick < this->nmintickval[ axis ]; itick++ ) {
            sprintf( buff, "MnTk%d_%d", axis + 1, itick + 1 );
            astWriteDouble( channel, buff, 1, 1,
                            this->mintickval[ axis ][ itick ], "" );
         }
      }
   }

/* Return. */
   return;

/* Undefine macros local to this function. */
#undef KEY_LEN
}


/* Standard class functions. */
/* ========================= */
/* Implement the astIsAPlot and astCheckPlot functions using
   the macros defined for this purpose in the "object.h" header
   file. */
astMAKE_ISA(Plot,FrameSet)
astMAKE_CHECK(Plot)

AstPlot *astPlot_( void *frame_void, const float *graphbox,
                   const double *basebox, const char *options, int *status, ...) {
/*
*+
*  Name:
*     astPlot

*  Purpose:
*     Create a Plot.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     AstPlot *astPlot( AstFrame *frame, const float *graphbox,
*                       const double *basebox, const char *options, ..., int *status )

*  Class Membership:
*     Plot constructor.

*  Description:
*     This function creates a new Plot and optionally initialises
*     its attributes.
*
*     The supplied Frame (or the base frame if a FrameSet was supplied) is
*     assumed to be related to the graphics world coordinate system by a
*     simple shift and scale along each axis. The mapping between graphics
*     world coordinates and this Frame is specified by supplying the
*     coordinates in both systems at the bottom left and top right corners
*     of a box on the graphics device. By default, no graphics will be
*     produced outside the supplied box, but this default behaviour can be
*     changed by setting explicit values for the various clipping attributes.

*  Parameters:
*     frame
*        A pointer to a Frame or FrameSet to be annotated. If a NULL pointer
*        is supplied, then a default 2-D Frame will be created to which labels,
*        etc, can be attached by setting the relevant Frame attributes.
*     graphbox
*        A pointer to an array of 4 values giving the graphics world
*        coordinates of the bottom left and top right corners of a box on
*        the graphics output device. The first pair of values should be the
*        coordinates of the bottom left corner of the box and the second
*        pair of values should be the coordinates of the top right corner.
*        The horizontal axis should be given first in each pair.
*     basebox
*        A pointer to an array of 4 values giving the coordinates in the
*        supplied Frame, or base frame of the supplied FrameSet, at the
*        bottom left and top right corners of the box specified by parameter
*        graphbox. These should be supplied in the same order as for
*        parameter "graphbox".
*     options
*        Pointer to a null terminated string containing an optional
*        comma-separated list of attribute assignments to be used for
*        initialising the new Plot. The syntax used is the same as
*        for the astSet method and may include "printf" format
*        specifiers identified by "%" symbols in the normal way.
*     status
*        Pointer to the inherited status variable.
*     ...
*        If the "options" string contains "%" format specifiers, then
*        an optional list of arguments may follow it in order to
*        supply values to be substituted for these specifiers. The
*        rules for supplying these are identical to those for the
*        astSet method (and for the C "printf" function).

*  Returned Value:
*     A pointer to the new Plot.

*  Notes:
*     -  The base Frame of the created Plot corresponds to the graphics world
*     coordinate system, and should not, in general, be changed.
*     -  The current Frame of the created Plot corresponds to the Frame
*     given by parameter "frame". If a FrameSet was supplied then its
*     current Frame becomes the current Frame of the created Plot.
*     - If the supplied Frame, or base Frame if a FrameSet was supplied,
*     has more than 2 axes, then the sub-Frame defined by the first 2 axes
*     is used.
*     -  A NULL pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*-

*  Implementation Notes:
*     - This function implements the basic Plot constructor which
*     is available via the protected interface to the Plot class.
*     A public interface is provided by the astPlotId_ function.
*     - Because this function has a variable argument list, it is
*     invoked by a macro that evaluates to a function pointer (not a
*     function invocation) and no checking or casting of arguments is
*     performed before the function is invoked. Because of this, the
*     "frame" parameter is of type (void *) and is converted and
*     validated within the function itself.

*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstFrame *frame;              /* Pointer to Frame structure */
   AstPlot *new;                 /* Pointer to new Plot */
   va_list args;                 /* Variable argument list */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Check the global status. */
   if ( !astOK ) return NULL;

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   new = NULL;

/* Obtain and validate a pointer to any supplied Frame structure. */
   if( frame_void ){
      frame = astCheckFrame( frame_void );
   } else {
      frame = NULL;
   }

/* Check the pointer can be used. */
   if ( astOK ) {

/* Initialise the Plot, allocating memory and initialising the
   virtual function table as well if necessary. */
      new = astInitPlot( NULL, sizeof( AstPlot ), !class_init,
                         &class_vtab, "Plot", frame, graphbox,
                         basebox );

/* If successful, note that the virtual function table has been
   initialised. */
      if ( astOK ) {
         class_init = 1;

/* Obtain the variable argument list and pass it along with the
   options string to the astVSet method to initialise the new
   Plot's attributes. */
         va_start( args, status );
         astVSet( new, options, NULL, args );
         va_end( args );

/* If an error occurred, clean up by deleting the new object. */
         if ( !astOK ) new = astDelete( new );
      }
   }

/* Return a pointer to the new Plot. */
   return new;
}

AstPlot *astInitPlot_( void *mem, size_t size, int init, AstPlotVtab *vtab,
                       const char *name, AstFrame *frame, const float *graphbox,
                       const double *basebox, int *status ) {
/*
*+
*  Name:
*     astInitPlot

*  Purpose:
*     Initialise a Plot.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "plot.h"
*     AstPlot *astInitPlot( void *mem, size_t size, int init,
*                           AstPlotVtab *vtab, const char *name,
*                           AstFrame *frame, const float *graphbox,
*                           const double *basebox )

*  Class Membership:
*     Plot initialiser.

*  Description:
*     This function is provided for use by class implementations to initialise
*     a new Plot object. It allocates memory (if necessary) to accommodate
*     the Plot plus any additional data associated with the derived class.
*     It then initialises a Plot structure at the start of this memory. If
*     the "init" flag is set, it also initialises the contents of a virtual
*     function table for a Plot at the start of the memory passed via the
*     "vtab" parameter.

*  Parameters:
*     mem
*        A pointer to the memory in which the Plot is to be created. This
*        must be of sufficient size to accommodate the Plot data
*        (sizeof(Plot)) plus any data used by the derived class. If a value
*        of NULL is given, this function will allocate the memory itself using
*        the "size" parameter to determine its size.
*     size
*        The amount of memory used by the Plot (plus derived class data).
*        This will be used to allocate memory if a value of NULL is given for
*        the "mem" parameter. This value is also stored in the Plot
*        structure, so a valid value must be supplied even if not required for
*        allocating memory.
*     init
*        A logical flag indicating if the Plot's virtual function table is
*        to be initialised. If this value is non-zero, the virtual function
*        table will be initialised by this function.
*     vtab
*        Pointer to the start of the virtual function table to be associated
*        with the new Plot. If NULL, the vtab associated with this class
*        (Plot) will be used.
*     name
*        Pointer to a constant null-terminated character string which contains
*        the name of the class to which the new object belongs (it is this
*        pointer value that will subsequently be returned by the astGetClass
*        method).
*     frame
*        A pointer to the Frame or Frameset to be annotated.
*     graphbox
*        A pointer to an array of 4 values giving the graphics coordinates
*        of the bottom left and top right corners of a box on the graphics
*        output device. The first pair of values should be the graphics
*        coordinates of the bottom left corner of the box and the second
*        pair of values are the graphics coordinates of the top right corner.
*        The horizontal axis should be given first in each pair.
*     basebox
*        A pointer to an array of 4 values giving the coordinates in the
*        supplied Frame or base Frame of the supplied FrameSet at the bottom
*        left and top right corners of the box specified by parameter graphbox.
*        These should be supplied in the same order as for parameter "graphbox".

*  Returned Value:
*     A pointer to the new Plot.

*  Notes:
*     - If the supplied Frame, or base Frame if a FrameSet was supplied,
*     has more than 2 axes, then the sub-Frame defined by the first 2 axes
*     is used.
*     -  The current Frame of the supplied FrameSet need not be 2-dimensional.
*     -  A null pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstFrame *baseframe;         /* Pointer to base frame */
   AstFrame *graphicsframe;     /* Pointer to graphics frame */
   AstFrameSet *fset0;          /* The n-D FrameSet to be annotated */
   AstFrameSet *fset;           /* The 2-D FrameSet to be annotated */
   AstPlot *new;                /* Pointer to new Plot */
   AstWinMap *map;              /* Mapping for converting bbox -> gbox */
   char *mess;                  /* Pointer to a descriptive message */
   double gbox[ 4 ];            /* Double precision version of "graphbox" */
   int axis;                    /* Axis index, 0 or 1 */
   int bi;                      /* Index of base frame */
   int ci;                      /* Index of current frame */
   int i;                       /* Loop count */
   int id;                      /* Plot object id */
   int naxes;                   /* No. of axes in frame */

/* Check the global status. */
   if ( !astOK ) return NULL;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(frame);

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   fset = NULL;
   mess = NULL;

/* If no vtab was supplied, use the vtab for this class (Plot). */
   if( !vtab ) {
      vtab = &class_vtab;
      if ( !class_init ) {
         astInitPlotVtab( vtab, "Plot" );
         class_init = 1;
      }

/* If necessary, initialise the virtual function table. */
   } else if ( init ) {
      astInitPlotVtab( vtab, name );
   }

/* Initialise. */
   new = NULL;
   baseframe = NULL;

/* First of all we need to ensure that we have a FrameSet and a base
   Frame on which to base the new Plot. If a NULL Frame pointer was
   supplied, create a default 2-D Frame, and then create a FrameSet
   containing just this default Frame. Also store a pointer to a
   message which can be used to describe the object within error
   messages. */
   if( !frame ){
      baseframe = astFrame( 2, "", status );
      fset = astFrameSet( baseframe, "", status );
      mess = "default 2-d Frame";

/* If an object was supplied, report an error if it is not a Frame or
   an object derived from a Frame (such as a FrameSet). */
   } else if( !astIsAFrame( frame ) ){
      if( astOK ){
         astError( AST__BDOBJ, "astInitPlot(%s): Supplied Object (class '%s') "
                   "is not a Frame.", status, name, astGetClass( frame ) );
      }

/* If the supplied object is a Plot or an object derived from a Plot (a Plot
   is a sort of Frame and so will pass the above test), extract a
   FrameSet from the Plot, and clear the Domain attribute for any existing
   Frames which have Domain GRAPHICS. */
   } else if( astIsAPlot( frame ) ){
      fset0 = astFrameSet( frame, "", status );
      fset = astCopy( fset0 );
      fset0 = astAnnul( fset0 );

      for( i = 0; i < astGetNframe( fset ); i++ ) {
         graphicsframe = astGetFrame( fset, i );
         if( !strcmp( astGetDomain( graphicsframe ), "GRAPHICS" ) ) {
            astClearDomain( graphicsframe );
         }
         graphicsframe = astAnnul( graphicsframe );
      }

      baseframe = astGetFrame( fset, astGetBase( fset ) );
      mess = "base Frame of the supplied Plot";

/* If the object is not a FrameSet, create a FrameSet holding the
   supplied Frame. If the Frame is not 2D, an extra 2D Frame is
   included in the FrameSet derived from axes 1 and 2 of the supplied
   Frame. This new Frame becomes the base Frame. */
   } else if( !astIsAFrameSet( frame ) ){
      fset0 = astFrameSet( frame, "", status );
      mess = "supplied Frame";
      fset = Fset2D( fset0, AST__BASE, status );
      fset0 = astAnnul( fset0 );
      baseframe = astGetFrame( fset, astGetBase( fset ) );

/* If a FrameSet was supplied, ensure it has a 2D base Frame.
   If the supplied FrameSet is not 2D, then a new base Frame is
   inserted into it which is derived from axes 1 and 2 of the
   original base Frame. */
   } else {
      fset = Fset2D( (AstFrameSet *) frame, AST__BASE, status );
      baseframe = astGetFrame( fset, astGetBase( fset ) );
      mess = "base Frame of the supplied FrameSet";
   }

/* Check that there are 2 axes in the base frame of the FrameSet. */
   naxes = astGetNaxes( baseframe );
   if ( naxes != 2 && astOK ) {
      astError( AST__NAXIN, "astInitPlot(%s): Number of axes (%d) in the %s "
                "is invalid - this number should be 2.", status, name, naxes, mess );
   }

/* Check that neither dimension of the graphbox is zero. */
   if( ( graphbox[ 2 ] == graphbox[ 0 ] ||
         graphbox[ 3 ] == graphbox[ 1 ] ) && astOK ){
      astError( AST__BADBX, "astInitPlot(%s): The plotting area has zero size "
                "in the graphics world coordinate system.", status, name );
   }

/* Check that neither dimension of the graphbox is bad. */
   if( astISBAD(graphbox[0]) || astISBAD(graphbox[1]) ||
       astISBAD(graphbox[2]) || astISBAD(graphbox[3]) ) {
      astError( AST__BADBX, "astInitPlot(%s): The plotting area has undefined limits "
                "in the graphics world coordinate system.", status, name );
   }

/* Check that neither dimension of the basebox is zero. */
   if( astISBAD(basebox[2]) || astISBAD(basebox[0]) ) {
      astError( AST__BADBX, "astInitPlot(%s): The limits of the horizontal "
                "axis of the %s are undefined or bad.", status, name, name );
   } else if( astISBAD(basebox[3]) || astISBAD(basebox[1]) ) {
      astError( AST__BADBX, "astInitPlot(%s): The limits of the vertical "
                "axis of the %s are undefined or bad.", status, name, name );
   }

/* Create a Frame which describes the graphics world coordinate system. */
   graphicsframe = astFrame( 2,
                             "Domain=GRAPHICS,Title=Graphical Coordinates", status );

/* Initialise a FrameSet structure (the parent class) as the first
   component within the Plot structure, allocating memory if necessary.
   The new FrameSet is initialised to hold the graphics Frame created
   above. */
   new = (AstPlot *) astInitFrameSet( mem, size, 0, (AstFrameSetVtab *) vtab,
                                      name, graphicsframe );

   if ( astOK ) {

/* Initialise the Plot data. */
/* ----------------------------- */

/* Get a double precision version of "graphbox". */
      gbox[ 0 ] = (double) graphbox[ 0 ];
      gbox[ 1 ] = (double) graphbox[ 1 ];
      gbox[ 2 ] = (double) graphbox[ 2 ];
      gbox[ 3 ] = (double) graphbox[ 3 ];

/* Store the bounds in graphics coordinates of the clipping box, ensuring
   that the low bound is lower than the high bound. Set flags to indicate
   if the supplied bounds has to be reversed to do this (some graphics
   system have the Y axis increasing from the top of the screen to the
   bottom). */
      if( graphbox[ 0 ] <= graphbox[ 2 ] ){
         new->xlo = gbox[ 0 ];
         new->xhi = gbox[ 2 ];
         new->xrev = 0;
      } else {
         new->xhi = gbox[ 0 ];
         new->xlo = gbox[ 2 ];
         new->xrev = 1;
         astSetDirection( graphicsframe, 0, 0 );
      }
       if( graphbox[ 1 ] <= graphbox[ 3 ] ){
         new->ylo = gbox[ 1 ];
         new->yhi = gbox[ 3 ];
         new->yrev = 0;
      } else {
         new->yhi = gbox[ 1 ];
         new->ylo = gbox[ 3 ];
         new->yrev = 1;
         astSetDirection( graphicsframe, 1, 0 );
      }

/* Store the bounds of the Plot within the base Frame of the supplied
   FrameSet. */
      new->bbox[ 0 ] = basebox[ 0 ];
      new->bbox[ 1 ] = basebox[ 1 ];
      new->bbox[ 2 ] = basebox[ 2 ];
      new->bbox[ 3 ] = basebox[ 3 ];

/* We initially assume that the base Frame of the supplied FrameSet is
   mapped lineary onto the graphics frame. This may be changed later by
   assigning values to the LogPlot attributes. Create a WinMap which
   maps the base box (within the base Frame of the supplied FrameSet)
   onto the graphics box. */
      map = astWinMap( 2, gbox, gbox + 2, basebox, basebox + 2, "", status );

/* Get the index of the current (physical) and base (pixel) Frames in
   the supplied FrameSet. */
      bi = astGetBase( fset );
      ci = astGetCurrent( fset );

/* Temporarily set the current Frame to be the pixel frame. */
      astSetCurrent( fset, bi );

/* Add the supplied FrameSet into the Plot (i.e. FrameSet) created
   earlier. This leaves the graphics frame with index 1 in the
   returned  Plot. We use the linear mapping initially. */
      astAddFrame( (AstFrameSet *) new, 1, map, fset );
      map = astAnnul( map );

/* Set the current Frame in the Plot to be the physical coordinate Frame
   (with index incremented by one because the graphics Frame has been added). */
      astSetCurrent( (AstFrameSet *) new, ci + 1 );

/* Re-establish the original current Frame in the supplied FrameSet. */
      astSetCurrent( fset, ci );

/* Store a value of -1.0 for Tol to indicate that no value has yet been
   set. This will cause a default value of 0.001 to be used. */
      new->tol = -1.0;

/* Set up default clipping information which gives no clipping. */
      new->clip_frame = AST__NOFRAME;
      new->clip_lbnd = NULL;
      new->clip_ubnd = NULL;
      new->clip_axes = 0;

/* Is a grid covering the plotting area required? Store a value of -1
   to indicate that no value has yet been set. This will cause a default
   value of 0 (no) to be used. */
      new->grid = -1;

/* Are tick marks to be placed on both edges in a pair of opposite edges?
   Store a value of -1 to indicate that no value has yet been set. This will
   cause a default value of 1 (yes) to be used. */
      new->tickall = -1;

/* Graphics context identifier */
      new->grfcontext = NULL;
      new->grfcontextID = NULL;

/* Shoudl ast Grid draw a boundary round the regions of valid coordinates?
   Store a value of -1 to indicate that no value has yet been set. This will
   cause a default value of 1 (yes) to be used. */
      new->border = -1;

/* Should graphics be drawn invisible? Store a value of -1 to indicate that
   no value has yet been set. This will cause a default value of 0 (no) to
   be used. */
      new->invisible = -1;

/* By default clip markers but not curves at the boundary of the plotting
   area. This was the only behaviour available prior to the introduction of
   the Clip attribute, and is chosen as the default to maintain backwards
   compatibility. */
      new->clip = -1;

/* Is clipping to be done using a logical OR operation between the axes?
   Store a value of -1 to indicate that no value has yet been set. This will
   cause a default value of 0 (no, i.e. a logical AND) to be used. */
      new->clipop = -1;

/* Is the graphics interface registered using astGrfSet to be used?
   Store a value of -1 to indicate that no value has yet been set. This will
   cause a default value of 0 (no, i.e. use the graphics interface
   selected at link-time) to be used. */
      new->grf = -1;

/* Wrapper functions to call the drawing routines. These are the
   default wrappers which call GRF routines written in C. Alternative
   wrappers are defined in fplot.c for use with GRF routines written in
   F77. */
      new->GAttr = CGAttrWrapper;
      new->GBBuf = CGBBufWrapper;
      new->GEBuf = CGEBufWrapper;
      new->GFlush = CGFlushWrapper;
      new->GLine = CGLineWrapper;
      new->GMark = CGMarkWrapper;
      new->GText = CGTextWrapper;
      new->GCap = CGCapWrapper;
      new->GTxExt = CGTxExtWrapper;
      new->GScales = CGScalesWrapper;
      new->GQch = CGQchWrapper;

      for( i = 0; i < AST__NGRFFUN; i++ ) new->grffun[i] = NULL;
      new->grfstack = NULL;
      new->grfnstack = 0;

/* Is a title to be added to an annotated grid? Store a value of -1 to
   indicate that no value has yet been set. This will cause a default value
   of 1 (yes) to be used. */
      new->drawtitle = -1;

/* Are escape sequences within text strings to be interpreted? If not,
   they are printed literally. Store a value of -1 when not set.
   This will cause a default value of 1 (yes) to be used. */
      new->escape = -1;

/* A boolean attribute indicating where numerical labels are to be
   placed; zero implies round the edges of the plotting area; non-zero
   implies within the plotting area. The unset value of -9999 yields a
   default of zero. */
      new->labelling = -9999;

/* A boolean attribute indicating how to offset the title and textual
   axis labels; zero implies relative to the bounding box containing the
   rest of the annotated axes (excluding other textual labels), and
   non-zero implies relative to the plotting area. The unset value of
   -9999 yields a default of zero. */
      new->textgaptype = -9999;

/* Graphics attributes. Default behaviour is to use the current values. */
      for( id = 0; id < AST__NPID; id++ ){
         new->style[ id ] = -1;
         new->font[ id ] = -1;
         new->colour[ id ] = -1;
         new->width[ id ] = AST__BAD;
         new->size[ id ] = AST__BAD;
      }

/* The space between the top edge and the grid title as a fraction of the
   minimum dimension of the plotting area. Store AST__BAD to indicate that no
   value has been set. This will cause a default of 0.05 to be used. */
      new->titlegap = AST__BAD;

/* Initialise the protected Ink attribute so that visible ink is used. */
      new->ink = -1;

/* A stack of AstGat pointers used to store the graphical attributes for
   text within strings which include graphical escape sequences. */
      new->gat = NULL;
      new->ngat = 0;

/* Now set the attribute values for each axis. The arrays stored in the
   Plot struture allow for 3 graphics axes (e.g. as used by a Plot3D) so
   we initialise 3 axes here even though the Plot class only uses 2. */
      for( axis = 0; axis < 3; axis++ ) {

/* Are curves to be drawn through the tick marks even if no grid is
   produced? Store a value of -1 to indicate that no value has yet been
   set. This will cause a default value of 1 (yes) to be used. */
         new->drawaxes[ axis ] = -1;

/* Are adjacent numerical axis labels to be abbreviated by removing matching
   leading fields? Store a value of -1 to indicate that no value has yet been
   set. This will cause a default value of 1 (yes) to be used. */
         new->abbrev[ axis ] = -1;

/* The length of the major tick marks as a fraction of the minimum
   dimension of the plotting area. Store AST__BAD to indicate that no
   value has been set. This will cause a default of 0.015 to be used. */
         new->majticklen[ axis ] = AST__BAD;

/* The length of the minor tick marks as a fraction of the minimum
   dimension of the plotting area. Store AST__BAD to indicate that no
   value has been set. This will cause a default of 0.007 to be used. */
         new->minticklen[ axis ] = AST__BAD;

/* Are numeric labels to be drawn upright? Store a value of -1 to indicate
   that no value has yet been set. This will cause a default value of 0 (no)
   to be used. */
         new->labelup[ axis ] = -1;

/* The space between an axis and its numeric labels as a fraction of the
   minimum dimension of the plotting area. Store AST__BAD to indicate that no
   value has been set. This will cause a default of 0.01 to be used. */
         new->numlabgap[ axis ] = AST__BAD;
         new->textlabgap[ axis ] = AST__BAD;

/* The edges on which to put labels for axes 1 and 2. Store values of -1
   to indicate that no values have been set. This will cause default values
   to be used. */
         new->edge[ axis ] = -1;

/* The placement of labels within the plotting area will be done
   automatically by default. */
         new->labelat[ axis ] = AST__BAD;

/* The central tick is placed automatically by default. */
         new->centre[ axis ] = AST__BAD;

/* The gap between tick marks and the number of minor tick marks will be
   found automatically by default. */
         new->gap[ axis ] = AST__BAD;
         new->loggap[ axis ] = AST__BAD;
         new->mintick[ axis ] = -1;

/* Both axes will be labelled by default. */
         new->numlab[ axis ] = -1;
         new->textlab[ axis ] = -1;
         new->labelunits[ axis ] = -1;

/* Log/lin attributes. Default value is to use linear axes. */
         new->logplot[ axis ] = -1;
         new->logticks[ axis ] = -1;
         new->loglabel[ axis ] = -1;

/* Initialise the components used to store the values actually used
   for attributes which have dynamic defaults. */
         new->ulglb[ axis ] = new->loglabel[ axis ];
         new->ulgtk[ axis ] = new->logticks[ axis ];
         new->uloggap[ axis ] = new->loggap[ axis ];
         new->ugap[ axis ] = new->gap[ axis ];
         new->ucentre[ axis ] = new->centre[ axis ];
         new->uedge[ axis ] = new->edge[ axis ];
         new->ulblat[ axis ] = new->labelat[ axis ];
         new->ulbunit[ axis ] = new->labelunits[ axis ];
         new->umintk[ axis ] = new->mintick[ axis ];
         new->utxtlb[ axis ] = new->textlab[ axis ];
         new->umjtkln[ axis ] = new->majticklen[ axis ];

/* Initialise the arrays used to hold information describing the tick
   marks that have been drawn for the axis. */
         new->majtickgx[ axis ] = NULL;
         new->majtickgy[ axis ] = NULL;
         new->majtickcount[ axis ] = 0;
         new->mintickgx[ axis ] = NULL;
         new->mintickgy[ axis ] = NULL;
         new->mintickcount[ axis ] = 0;
         new->nmajtickval[ axis ] = 0;
         new->majtickval[ axis ] = NULL;
         new->nmintickval[ axis ] = 0;
         new->mintickval[ axis ] = NULL;
      }

      new->ugrid = new->grid;
      new->ulbling = new->labelling;
      new->uborder = new->border;

   }

/* Annul the frame. */
   graphicsframe = astAnnul( graphicsframe );

/* If an error occurred, clean up by deleting the new object. */
   if ( !astOK ) new = astDelete( new );

/* Annul the pointer to the base Frame and FrameSet. */
   baseframe = astAnnul( baseframe );
   fset = astAnnul( fset );

/* Return a pointer to the new object. */
   return new;
}

AstPlot *astLoadPlot_( void *mem, size_t size,
                       AstPlotVtab *vtab, const char *name,
                       AstChannel *channel, int *status ) {
/*
*+
*  Name:
*     astLoadPlot

*  Purpose:
*     Load a Plot.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "Plot.h"
*     AstPlot *astLoadPlot( void *mem, size_t size,
*                           AstPlotVtab *vtab, const char *name,
*                           AstChannel *channel )

*  Class Membership:
*     Plot loader.

*  Description:
*     This function is provided to load a new Plot using data read
*     from a Channel. It first loads the data used by the parent class
*     (which allocates memory if necessary) and then initialises a
*     Plot structure in this memory, using data read from the input
*     Channel.
*
*     If the "init" flag is set, it also initialises the contents of a
*     virtual function table for a Plot at the start of the memory
*     passed via the "vtab" parameter.


*  Parameters:
*     mem
*        A pointer to the memory into which the Plot is to be
*        loaded.  This must be of sufficient size to accommodate the
*        Plot data (sizeof(Plot)) plus any data used by derived
*        classes. If a value of NULL is given, this function will
*        allocate the memory itself using the "size" parameter to
*        determine its size.
*     size
*        The amount of memory used by the Plot (plus derived class
*        data).  This will be used to allocate memory if a value of
*        NULL is given for the "mem" parameter. This value is also
*        stored in the Plot structure, so a valid value must be
*        supplied even if not required for allocating memory.
*
*        If the "vtab" parameter is NULL, the "size" value is ignored
*        and sizeof(AstPlot) is used instead.
*     vtab
*        Pointer to the start of the virtual function table to be
*        associated with the new Plot. If this is NULL, a pointer
*        to the (static) virtual function table for the Plot class
*        is used instead.
*     name
*        Pointer to a constant null-terminated character string which
*        contains the name of the class to which the new object
*        belongs (it is this pointer value that will subsequently be
*        returned by the astGetClass method).
*
*        If the "vtab" parameter is NULL, the "name" value is ignored
*        and a pointer to the string "Plot" is used instead.

*  Returned Value:
*     A pointer to the new Plot.

*  Notes:
*     - A null pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

#define KEY_LEN 50               /* Maximum length of a keyword */

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstPlot *new;                 /* Pointer to the new Plot */
   char buff[ KEY_LEN + 1 ];     /* Buffer for keyword string */
   char *text;                   /* Textual version of integer value */
   int axis;                     /* Zero based axis index */
   int id;                       /* Zero based graphical object id */
   int i;                        /* Loop count */
   int itick;                    /* Tick mark index */
   int nax;                      /* Number of base Frame axes */
   int ntick;                    /* Total number of ticks */

/* Initialise. */
   new = NULL;

/* Check the global error status. */
   if ( !astOK ) return new;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(channel);

/* If a NULL virtual function table has been supplied, then this is
   the first loader to be invoked for this Plot. In this case the
   Plot belongs to this class, so supply appropriate values to be
   passed to the parent class loader (and its parent, etc.). */
   if ( !vtab ) {
      size = sizeof( AstPlot );
      vtab = &class_vtab;
      name = "Plot";

/* If required, initialise the virtual function table for this class. */
      if ( !class_init ) {
         astInitPlotVtab( vtab, name );
         class_init = 1;
      }
   }

/* Invoke the parent class loader to load data for all the ancestral
   classes of the current one, returning a pointer to the resulting
   partly-built Plot. */
   new = astLoadFrameSet( mem, size, (AstFrameSetVtab *) vtab, name,
                          channel );

   if ( astOK ) {

/* Get the number of graphics (base) frame axes - 2 for a Plot, 3 for a
   Plot3D. */
   nax = astGetNin( new );

/* Read input data. */
/* ================ */
/* Request the input Channel to read all the input data appropriate to
   this class into the internal "values list". */
      astReadClassData( channel, "Plot" );

/* Now read each individual data item from this list and use it to
   initialise the appropriate instance variable(s) for this class. */

/* In the case of attributes, we first read the "raw" input value,
   supplying the "unset" value as the default. If a "set" value is
   obtained, we then use the appropriate (private) Set... member
   function to validate and set the value properly. */

/* Tol. */
/* ---- */
      new->tol = astReadDouble( channel, "tol", -1.0 );
      if ( TestTol( new, status ) ) SetTol( new, new->tol, status );

/* Grid. */
/* ----- */
      new->grid = astReadInt( channel, "grid", -1 );
      if ( TestGrid( new, status ) ) SetGrid( new, new->grid, status );

/* TickAll. */
/* -------- */
      new->tickall = astReadInt( channel, "tckall", -1 );
      if ( TestTickAll( new, status ) ) SetTickAll( new, new->tickall, status );

/* ForceExterior. */
/* -------- */
      new->forceexterior = astReadInt( channel, "frcext", -1 );
      if ( TestForceExterior( new, status ) ) SetForceExterior( new, new->forceexterior, status );

/* Invisible. */
/* ---------- */
      new->invisible = astReadInt( channel, "invsbl", -1 );
      if ( TestInvisible( new, status ) ) SetInvisible( new, new->invisible, status );

/* Border. */
/* -------- */
      new->border = astReadInt( channel, "border", -1 );
      if ( TestBorder( new, status ) ) SetBorder( new, new->border, status );

/* ClipOp. */
/* ------- */
      new->clipop = astReadInt( channel, "clpop", -1 );
      if ( TestClipOp( new, status ) ) SetClipOp( new, new->clipop, status );

/* Clip. */
/* ----- */
      new->clip = astReadInt( channel, "clip", -1 );
      if ( TestClip( new, status ) ) SetClip( new, new->clip, status );

/* DrawTitle. */
/* --------- */
      new->drawtitle = astReadInt( channel, "drwttl", -1 );
      if ( TestDrawTitle( new, status ) ) SetDrawTitle( new, new->drawtitle, status );

/* LabelUp(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lblup%d", axis + 1 );
         new->labelup[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestLabelUp( new, axis, status ) ) SetLabelUp( new, axis,
                                                     new->labelup[ axis ], status );
      }

/* LogPlot(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lgplt%d", axis + 1 );
         new->logplot[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestLogPlot( new, axis, status ) ) SetLogPlot( new, axis,
                                                     new->logplot[ axis ], status );
      }

/* LogTicks(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lgtck%d", axis + 1 );
         new->logticks[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestLogTicks( new, axis, status ) ) SetLogTicks( new, axis,
                                                       new->logticks[ axis ], status );
      }

/* LogLabel(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lglbl%d", axis + 1 );
         new->loglabel[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestLogLabel( new, axis, status ) ) SetLogLabel( new, axis,
                                                       new->loglabel[ axis ], status );
      }

/* DrawAxes. */
/* --------- */
      new->drawaxes[ 0 ] = astReadInt( channel, "drwaxs", -1 );

      if(  new->drawaxes[ 0 ] != -1 ) {
         new->drawaxes[ 1 ] = new->drawaxes[ 0 ];
         if ( TestDrawAxes( new, 0, status ) ) SetDrawAxes( new, 0, new->drawaxes[ 0 ], status );
         if ( TestDrawAxes( new, 1, status ) ) SetDrawAxes( new, 1, new->drawaxes[ 1 ], status );

      } else {
         for( axis = 0; axis < nax; axis++ ){
            (void) sprintf( buff, "drwaxs%d", axis + 1 );
            new->drawaxes[ axis ] = astReadInt( channel, buff, -1 );
            if ( TestDrawAxes( new, axis, status ) ) SetDrawAxes( new, axis,
                                                       new->drawaxes[ axis ], status );
         }
      }

/* Abbrev. */
/* ------- */
      new->abbrev[ 0 ] = astReadInt( channel, "abbrv", -1 );

      if(  new->abbrev[ 0 ] != -1 ) {
         new->abbrev[ 1 ] = new->abbrev[ 0 ];
         if ( TestAbbrev( new, 0, status ) ) SetAbbrev( new, 0, new->abbrev[ 0 ], status );
         if ( TestAbbrev( new, 1, status ) ) SetAbbrev( new, 1, new->abbrev[ 1 ], status );

      } else {
         for( axis = 0; axis < nax; axis++ ){
            (void) sprintf( buff, "abbrv%d", axis + 1 );
            new->abbrev[ axis ] = astReadInt( channel, buff, -1 );
            if ( TestAbbrev( new, axis, status ) ) SetAbbrev( new, axis,
                                                       new->abbrev[ axis ], status );
         }
      }


/* Escape. */
/* ------- */
      new->escape = astReadInt( channel, "escape", -1 );
      if ( TestEscape( new, status ) ) SetEscape( new, new->escape, status );

/* LabelAt(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lblat%d", axis + 1 );
         new->labelat[ axis ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestLabelAt( new, axis, status ) ) SetLabelAt( new, axis,
                                                     new->labelat[ axis ], status );
      }

/* Centre(axis). */
/* ------------ */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "cen%d", axis + 1 );
         new->centre[ axis ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestCentre( new, axis, status ) ) SetCentre( new, axis,
                                                   new->centre[ axis ], status );
      }

/* Gap(axis). */
/* ---------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "gap%d", axis + 1 );
         new->gap[ axis ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestGap( new, axis, status ) ) SetGap( new, axis, new->gap[ axis ], status );
      }

/* LogGap(axis). */
/* ------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lggap%d", axis + 1 );
         new->loggap[ axis ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestLogGap( new, axis, status ) ) SetLogGap( new, axis, new->loggap[ axis ], status );
      }

/* NumLabGap(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "nmgap%d", axis + 1 );
         new->numlabgap[ axis ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestNumLabGap( new, axis, status ) ) SetNumLabGap( new, axis,
                                                     new->numlabgap[ axis ], status );
      }

/* TextLabGap(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "txgap%d", axis + 1 );
         new->textlabgap[ axis ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestTextLabGap( new, axis, status ) ) SetTextLabGap( new, axis,
                                                     new->textlabgap[ axis ], status );
      }

/* NumLab(axis). */
/* ---------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "nmlbl%d", axis + 1 );
         new->numlab[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestNumLab( new, axis, status ) ) SetNumLab( new, axis,
                                                     new->numlab[ axis ], status );
      }

/* MinTick(axis). */
/* --------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "mntks%d", axis + 1 );
         new->mintick[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestMinTick( new, axis, status ) ) SetMinTick( new, axis,
                                                       new->mintick[ axis ], status );
      }

/* TextLab(axis). */
/* -------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "txlbl%d", axis + 1 );
         new->textlab[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestTextLab( new, axis, status ) ) SetTextLab( new, axis,
                                                      new->textlab[ axis ], status );
      }

/* LabelUnits(axis). */
/* --------------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "lbunt%d", axis + 1 );
         new->labelunits[ axis ] = astReadInt( channel, buff, -1 );
         if ( TestLabelUnits( new, axis, status ) ) SetLabelUnits( new, axis,
                                                      new->labelunits[ axis ], status );
      }

/* Style(object). */
/* ------------ */
      for( id = 0; id < AST__NPID; id++ ){
         (void) sprintf( buff, "style%d", id + 1 );
         new->style[ id ] = astReadInt( channel, buff, -1 );
         if ( TestStyle( new, id, status ) ) SetStyle( new, id, new->style[ id ], status );
      }

/* Font(object). */
/* ----------- */
      for( id = 0; id < AST__NPID; id++ ){
         (void) sprintf( buff, "font%d", id + 1 );
         new->font[ id ] = astReadInt( channel, buff, -1 );
         if ( TestFont( new, id, status ) ) SetFont( new, id, new->font[ id ], status );
      }

/* Colour(object). */
/* --------------- */
      for( id = 0; id < AST__NPID; id++ ){
         (void) sprintf( buff, "col%d", id + 1 );
         new->colour[ id ] = astReadInt( channel, buff, -1 );
         if ( TestColour( new, id, status ) ) SetColour( new, id, new->colour[ id ], status );
      }

/* Width(object). */
/* ------------ */
      for( id = 0; id < AST__NPID; id++ ){
         (void) sprintf( buff, "width%d", id + 1 );
         new->width[ id ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestWidth( new, id, status ) ) SetWidth( new, id, new->width[ id ], status );
      }

/* Size(object). */
/* ----------- */
      for( id = 0; id < AST__NPID; id++ ){
         (void) sprintf( buff, "size%d", id + 1 );
         new->size[ id ] = astReadDouble( channel, buff, AST__BAD );
         if ( TestSize( new, id, status ) ) SetSize( new, id, new->size[ id ], status );
      }

/* TitleGap. */
/* --------- */
      new->titlegap = astReadDouble( channel, "ttlgap", AST__BAD );
      if ( TestTitleGap( new, status ) ) SetTitleGap( new, new->titlegap, status );

/* MajTickLen. */
/* ----------- */
/* Retained in order to read old Plots - new Plots use MajTickLen(axis). */
      new->majticklen[ 0 ] = astReadDouble( channel, "mjtkln", AST__BAD );
      if( new->majticklen[ 0 ] != AST__BAD ) {
         new->majticklen[ 1 ] = new->majticklen[ 0 ];
         if ( TestMajTickLen( new, 0, status ) ) SetMajTickLen( new, 0, new->majticklen[ 0 ], status );
         if ( TestMajTickLen( new, 1, status ) ) SetMajTickLen( new, 1, new->majticklen[ 1 ], status );

/* MajTickLen(axis). */
/* ----------------- */
      } else {
         for( axis = 0; axis < nax; axis++ ){
            (void) sprintf( buff, "mjtkln%d", axis + 1 );
            new->majticklen[ axis ] = astReadDouble( channel, buff, AST__BAD );
            if ( TestMajTickLen( new, axis, status ) ) SetMajTickLen( new, axis,
                                                        new->majticklen[ axis ], status );
         }
      }

/* MinTickLen. */
/* ----------- */
/* Retained in order to read old Plots - new Plots use MinTickLen(axis). */
      new->minticklen[ 0 ] = astReadDouble( channel, "mntkln", AST__BAD );
      if( new->minticklen[ 0 ] != AST__BAD ) {
         new->minticklen[ 1 ] = new->minticklen[ 0 ];
         if ( TestMinTickLen( new, 0, status ) ) SetMinTickLen( new, 0, new->minticklen[ 0 ], status );
         if ( TestMinTickLen( new, 1, status ) ) SetMinTickLen( new, 1, new->minticklen[ 1 ], status );

/* MinTickLen(axis). */
/* ----------------- */
      } else {
         for( axis = 0; axis < nax; axis++ ){
            (void) sprintf( buff, "mntkln%d", axis + 1 );
            new->minticklen[ axis ] = astReadDouble( channel, buff, AST__BAD );
            if ( TestMinTickLen( new, axis, status ) ) SetMinTickLen( new, axis,
                                                        new->minticklen[ axis ], status );
         }
      }

/* Labelling. */
/* ---------- */
      text = astReadString( channel, "lbling", " " );
      if( astOK && strcmp( text, " " ) ) {
         new->labelling = FindString( 2, xlbling, text,
                                      "the Plot component 'Lbling'",
                                      "astRead", astGetClass( channel ), status );
      } else {
         new->labelling = -9999;
      }
      if ( TestLabelling( new, status ) ) SetLabelling( new, new->labelling, status );
      text = astFree( text );

/* TextGapType. */
/* ---------- */
      text = astReadString( channel, "tgaptyp", " " );
      if( astOK && strcmp( text, " " ) ) {
         new->textgaptype = FindString( 2, xtgaptype, text,
                                      "the Plot component 'TGapTyp'",
                                      "astRead", astGetClass( channel ), status );
      } else {
         new->textgaptype = -9999;
      }
      if ( TestTextGapType( new, status ) ) SetTextGapType( new, new->textgaptype, status );
      text = astFree( text );

/* Edge(axis). */
/* ----------- */
      for( axis = 0; axis < nax; axis++ ){
         (void) sprintf( buff, "edge%d", axis + 1 );
         text = astReadString( channel, buff, " " );
         if( astOK && strcmp( text, " " ) ) {
            new->edge[ axis ] = FindString( 4, xedge, text,
                                            "the Plot component 'Edge'",
                                            "astRead", astGetClass( channel ), status );
         } else {
            new->edge[ axis ] = -1;
         }
         if ( TestEdge( new, axis, status ) ) SetEdge( new, axis,
                                               new->edge[ axis ], status );
         text = astFree( text );
      }

/* Now do instance variables which are not attributes. */
/* =================================================== */

/* We have no graphics context. */
      new->grfcontext = NULL;
      new->grfcontextID = NULL;

/* Initialise the protected Ink attribute so that visible ink is used. */
      new->ink = -1;

/* The number of bounds supplied for the clipping volume. */
      new->clip_axes = astReadInt( channel, "clpaxs", 0 );
      if ( new->clip_axes < 0 ) new->clip_axes = 0;

/* The index of the clipping Frame within the Plot. */
      new->clip_frame = astReadInt( channel, "clpfrm", AST__NOFRAME );

/* If necessary, allocate memory to hold the bounds of the clipping volume. */
      if( new->clip_axes > 0 ){
         new->clip_lbnd = astMalloc( sizeof( double ) * (size_t) new->clip_axes );
         new->clip_ubnd = astMalloc( sizeof( double ) * (size_t) new->clip_axes );

/* If an error occurs, ensure that all allocated memory is freed. */
         if ( !astOK ) {
            new->clip_lbnd = (double *) astFree( (void *) new->clip_lbnd );
            new->clip_ubnd = (double *) astFree( (void *) new->clip_ubnd );

/* Otherwise, store the bounds. Use extreme defaults if no values are
   available. */
         } else {
            for( axis = 0; axis < new->clip_axes; axis++ ){
               (void) sprintf( buff, "clplb%d", axis + 1 );
               new->clip_lbnd[ axis ] = astReadDouble( channel, buff, -DBL_MAX );

               (void) sprintf( buff, "clpub%d", axis + 1 );
               new->clip_ubnd[ axis ] = astReadDouble( channel, buff, DBL_MAX );
            }
         }

/* If there are no clipping axes, store NULL pointers for the bounds
   arrays. */
      } else {
         new->clip_lbnd = NULL;
         new->clip_ubnd = NULL;
      }

/* The bounds of the plotting area in graphics coords. */
      new->xlo = astReadDouble( channel, "xlo", 0.0 );
      new->xhi = astReadDouble( channel, "xhi", 1.0 );
      new->ylo = astReadDouble( channel, "ylo", 0.0 );
      new->yhi = astReadDouble( channel, "yhi", 1.0 );

/* Axis reversal flags. */
      new->xrev = astReadInt( channel, "xrev", 0 );
      new->yrev = astReadInt( channel, "yrev", 0 );

/* The bounds of the plotting area in the base Frame of the FrameSet
   supplied when the Plot was constructed. */
      new->bbox[ 0 ] = astReadDouble( channel, "xb1", AST__BAD );
      new->bbox[ 1 ] = astReadDouble( channel, "yb1", AST__BAD );
      new->bbox[ 2 ] = astReadDouble( channel, "xb2", AST__BAD );
      new->bbox[ 3 ] = astReadDouble( channel, "yb2", AST__BAD );

/* Grf. */
      new->grf = -1;
      new->GAttr = CGAttrWrapper;
      new->GBBuf = CGBBufWrapper;
      new->GEBuf = CGEBufWrapper;
      new->GFlush = CGFlushWrapper;
      new->GLine = CGLineWrapper;
      new->GMark = CGMarkWrapper;
      new->GText = CGTextWrapper;
      new->GCap = CGCapWrapper;
      new->GTxExt = CGTxExtWrapper;
      new->GScales = CGScalesWrapper;
      new->GQch = CGQchWrapper;
      for( i = 0; i < AST__NGRFFUN; i++ ) new->grffun[i] = NULL;
      new->grfstack = NULL;
      new->grfnstack = 0;

/* A stack of AstGat pointers used to store the graphical attributes for
   text within strings which include graphical escape sequences. */
      new->gat = NULL;
      new->ngat = 0;

/* Arrays holding user-specified major and minot tick mark values. */
      for( axis = 0; axis < 3; axis++ ) {
         sprintf( buff, "nmjtk%d", axis + 1 );
         ntick = astReadInt( channel, buff, 0 );
         new->nmajtickval[ axis ] = ntick;
         new->majtickval[ axis ] = astMalloc( ntick*sizeof( double ) );

         for( itick = 0; itick < ntick; itick++ ) {
            sprintf( buff, "mjtk%d_%d", axis + 1, itick + 1 );
            new->majtickval[ axis ][ itick ] = astReadDouble( channel, buff,
                                                              AST__BAD );
         }

         sprintf( buff, "nmntk%d", axis + 1 );
         ntick = astReadInt( channel, buff, 0 );
         new->nmintickval[ axis ] = ntick;
         new->mintickval[ axis ] = astMalloc( ntick*sizeof( double ) );

         for( itick = 0; itick < ntick; itick++ ) {
            sprintf( buff, "mntk%d_%d", axis + 1, itick + 1 );
            new->mintickval[ axis ][ itick ] = astReadDouble( channel, buff,
                                                              AST__BAD );
         }

      }

/* Initialise the arrays used to hold information describing the tick
   marks that have already been drawn for each axis. */
      for( axis = 0; axis < 3; axis++ ) {
         new->majtickgx[ axis ] = NULL;
         new->majtickgy[ axis ] = NULL;
         new->majtickcount[ axis ] = 0;
         new->mintickgx[ axis ] = NULL;
         new->mintickgy[ axis ] = NULL;
         new->mintickcount[ axis ] = 0;
      }

/* If an error occurred, clean up by deleting the new Plot. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return the new Plot pointer. */
   return new;
}

/* Virtual function interfaces. */
/* ============================ */
/* These provide the external interface to the virtual functions defined by
   this class. Each simply checks the global error status and then locates and
   executes the appropriate member function, using the function pointer stored
   in the object's virtual function table (this pointer is located using the
   astMEMBER macro defined in "object.h").
    Note that the member function may not be the one defined here, as it may
   have been over-ridden by a derived class. However, it should still have the
   same interface. */

void astBBuf_( AstPlot *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,BBuf))(this, status );
}

int astBorder_( AstPlot *this, int *status ){
   if( !astOK ) return 0;
   return (**astMEMBER(this,Plot,Border))(this, status );
}

void astBoundingBox_( AstPlot *this, float lbnd[2], float ubnd[2], int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,BoundingBox))(this,lbnd,ubnd, status );
}

void astClip_( AstPlot *this, int iframe, const double lbnd[],
const double ubnd[], int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,Clip))(this,iframe,lbnd,ubnd, status );
}

void astGrid_( AstPlot *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,Grid))(this, status );
}

int astCvBrk_( AstPlot *this, int ibrk, double *brk, double *vbrk,
                   double *len, int *status ){
   if( !astOK ) return 0;
   return (**astMEMBER(this,Plot,CvBrk))(this,ibrk,brk,vbrk,len, status );
}

void astEBuf_( AstPlot *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,EBuf))(this, status );
}

void astMirror_( AstPlot *this, int axis, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,Mirror))(this,axis, status );
}

AstPointSet *astGetDrawnTicks_( AstPlot *this, int axis, int major, int *status ){
   if( !astOK ) return NULL;
   return (**astMEMBER(this,Plot,GetDrawnTicks))(this,axis,major, status );
}

void astSetTickValues_( AstPlot *this, int axis, int nmajor, double *major,
                           int nminor, double *minor, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,SetTickValues))(this,axis,nmajor,major,nminor,minor, status );
}

void astCopyPlotDefaults_( AstPlot *this, int axis, AstPlot *dplot,
                           int daxis, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,CopyPlotDefaults))(this,axis,dplot,daxis, status );
}

int astGetLabelUnits_( AstPlot *this, int axis, int *status ){
   if( !astOK ) return 0;
   return (**astMEMBER(this,Plot,GetLabelUnits))(this,axis, status );
}

void astMark_( AstPlot *this, int nmark, int ncoord, int indim,
               const double *in, int type, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Plot,Mark))( this, nmark, ncoord, indim, in, type, status );
}

void astText_( AstPlot *this, const char *text, const double pos[],
               const float up[], const char *just, int *status ){
   if ( !astOK ) return;
   (**astMEMBER(this,Plot,Text))( this, text, pos, up, just, status );
}

void astGridLine_( AstPlot *this, int axis, const double start[], double length, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,GridLine))(this,axis,start,length, status );
}

void astCurve_( AstPlot *this, const double start[], const double finish[], int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,Curve))(this,start,finish, status );
}

void astGenCurve_( AstPlot *this, AstMapping *map, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,GenCurve))(this,map, status );
}

void astPolyCurve_( AstPlot *this, int npoint, int ncoord, int dim,
                    const double *in, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,PolyCurve))(this,npoint,ncoord,dim,in, status );
}

void astRegionOutline_( AstPlot *this, AstRegion *region, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,RegionOutline))(this,region,status);
}

void astGrfSet_( AstPlot *this, const char *name, AstGrfFun fun, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,GrfSet))(this,name,fun, status );
}

void astGrfPush_( AstPlot *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,GrfPush))(this, status );
}

void astGrfPop_( AstPlot *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,GrfPop))(this, status );
}

void astGrfWrapper_( AstPlot *this, const char *name, AstGrfWrap wrapper, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,Plot,GrfWrapper))(this,name,wrapper, status );
}

void astSetLogPlot_( AstPlot *this, int axis, int value, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Plot,SetLogPlot))( this, axis, value, status );
}

void astClearLogPlot_( AstPlot *this, int axis, int *status ) {
   if ( !astOK ) return;
   (**astMEMBER(this,Plot,ClearLogPlot))( this, axis, status );
}

AstKeyMap *astGetGrfContext_( AstPlot *this, int *status ) {
   if ( !astOK ) return NULL;
   return (**astMEMBER(this,Plot,GetGrfContext))( this, status );
}

/* Special public interface functions. */
/* =================================== */
/* These provide the public interface to certain special functions
   whose public interface cannot be handled using macros (such as
   astINVOKE) alone. In general, they are named after the
   corresponding protected version of the function, but with "Id"
   appended to the name. */

/* Special interface function implementations. */
/* ------------------------------------------- */
AstPlot *astPlotId_( void *frame_void, const float graphbox[4],
                     const double basebox[4], const char *options, ... ) {
/*
*++
*  Name:
c     astPlot
f     AST_PLOT

*  Purpose:
*     Create a Plot.

*  Type:
*     Public function.

*  Synopsis:
c     #include "plot.h"
c     AstPlot *astPlot( AstFrame *frame, const float graphbox[ 4 ],
c                       const double basebox[ 4 ], const char *options, ... )
f     RESULT = AST_PLOT( FRAME, GRAPHBOX, BASEBOX, OPTIONS, STATUS )

*  Class Membership:
*     Plot constructor.

*  Description:
*     This function creates a new Plot and optionally initialises its
*     attributes.
*
*     A Plot is a specialised form of FrameSet, in which the base
*     Frame describes a "graphical" coordinate system and is
*     associated with a rectangular plotting area in the underlying
*     graphics system. This plotting area is where graphical output
*     appears. It is defined when the Plot is created.
*
*     The current Frame of a Plot describes a "physical" coordinate
*     system, which is the coordinate system in which plotting
*     operations are specified. The results of each plotting operation
*     are automatically transformed into graphical coordinates so as
*     to appear in the plotting area (subject to any clipping which
*     may be in effect).
*
*     Because the Mapping between physical and graphical coordinates
*     may often be non-linear, or even discontinuous, most plotting
*     does not result in simple straight lines. The basic plotting
*     element is therefore not a straight line, but a geodesic curve
c     (see astCurve). A Plot also provides facilities for drawing
c     markers or symbols (astMark), text (astText) and grid lines
c     (astGridLine). It is also possible to draw curvilinear axes with
c     optional coordinate grids (astGrid).
f     (see AST_CURVE). A Plot also provides facilities for drawing
f     markers or symbols (AST_MARK), text (AST_TEXT) and grid lines
f     (AST_GRIDLINE). It is also possible to draw curvilinear axes
f     with optional coordinate grids (AST_GRID).
*     A range of Plot attributes is available to allow precise control
*     over the appearance of graphical output produced by these
c     functions.
f     routines.
*
*     You may select different physical coordinate systems in which to
*     plot (including the native graphical coordinate system itself)
*     by selecting different Frames as the current Frame of a Plot,
*     using its Current attribute.  You may also set up clipping (see
c     astClip) to limit the extent of any plotting you perform, and
f     AST_CLIP) to limit the extent of any plotting you perform, and
*     this may be done in any of the coordinate systems associated
*     with the Plot, not necessarily the one you are plotting in.
*
*     Like any FrameSet, a Plot may also be used as a Frame. In this
*     case, it behaves like its current Frame, which describes the
*     physical coordinate system.
*
*     When used as a Mapping, a Plot describes the inter-relation
*     between graphical coordinates (its base Frame) and physical
*     coordinates (its current Frame).  It differs from a normal
*     FrameSet, however, in that an attempt to transform points which
*     lie in clipped areas of the Plot will result in bad coordinate
*     values (AST__BAD).

*  Parameters:
c     frame
f     FRAME = INTEGER (Given)
*        Pointer to a Frame describing the physical coordinate system
*        in which to plot. A pointer to a FrameSet may also be given,
*        in which case its current Frame will be used to define the
*        physical coordinate system and its base Frame will be mapped
*        on to graphical coordinates (see below).
*
*        If a null Object pointer (AST__NULL) is given, a default
*        2-dimensional Frame will be used to describe the physical
*        coordinate system. Labels, etc. may then be attached to this
*        by setting the appropriate Frame attributes
*        (e.g. Label(axis)) for the Plot.
c     graphbox
f     GRAPHBOX( 4 ) = REAL (Given)
*        An array giving the position and extent of the plotting area
*        (on the plotting surface of the underlying graphics system)
*        in which graphical output is to appear. This must be
*        specified using graphical coordinates appropriate to the
*        underlying graphics system.
*
*        The first pair of values should give the coordinates of the
*        bottom left corner of the plotting area and the second pair
*        should give the coordinates of the top right corner. The
*        coordinate on the horizontal axis should be given first in
*        each pair. Note that the order in which these points are
*        given is important because it defines up, down, left and
*        right for subsequent graphical operations.
c     basebox
f     BASEBOX( 4 ) = DOUBLE PRECISION (Given)
*        An array giving the coordinates of two points in the supplied
*        Frame (or in the base Frame if a FrameSet was supplied) which
*        correspond to the bottom left and top right corners of the
*        plotting area, as specified above. This range of coordinates
*        will be mapped linearly on to the plotting area. The
*        coordinates should be given in the same order as above.
c     options
f     OPTIONS = CHARACTER * ( * ) (Given)
c        Pointer to a null-terminated string containing an optional
c        comma-separated list of attribute assignments to be used for
c        initialising the new Plot. The syntax used is identical to
c        that for the astSet function and may include "printf" format
c        specifiers identified by "%" symbols in the normal way.
c        If no initialisation is required, a zero-length string may be
c        supplied.
f        A character string containing an optional comma-separated
f        list of attribute assignments to be used for initialising the
f        new Plot. The syntax used is identical to that for the
f        AST_SET routine. If no initialisation is required, a blank
f        value may be supplied.
c     ...
c        If the "options" string contains "%" format specifiers, then
c        an optional list of additional arguments may follow it in
c        order to supply values to be substituted for these
c        specifiers. The rules for supplying these are identical to
c        those for the astSet function (and for the C "printf"
c        function).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astPlot()
f     AST_PLOT
*        A pointer to the new Plot.

*  Notes:
*     - The base Frame of the returned Plot will be a new Frame which
*     is created by this function to represent the coordinate system
*     of the underlying graphics system (graphical coordinates). It is
*     given a Frame index of 1 within the Plot. The choice of base
*     Frame (Base attribute) should not, in general, be changed once a
*     Plot has been created (although you could use this as a way of
*     moving the plotting area around on the plotting surface).
c     - If a Frame is supplied (via the "frame" pointer), then it
f     - If a Frame is supplied (via the FRAME pointer), then it
*     becomes the current Frame of the new Plot and is given a Frame
*     index of 2.
c     - If a FrameSet is supplied (via the "frame" pointer), then
f     - If a FrameSet is supplied (via the FRAME pointer), then
*     all the Frames within this FrameSet become part of the new Plot
*     (where their Frame indices are increased by 1), with the
*     FrameSet's current Frame becoming the current Frame of the Plot.
*     - If a null Object pointer (AST__NULL) is supplied (via the
c     "frame" pointer), then the returned Plot will contain two
f     FRAME pointer), then the returned Plot will contain two
*     Frames, both created by this function. The base Frame will
*     describe graphics coordinates (as above) and the current Frame
*     will be a basic Frame with no attributes set (this will
*     therefore give default values for such things as the Plot Title
*     and the Label on each axis). Physical coordinates will be mapped
*     linearly on to graphical coordinates.
*     - An error will result if the Frame supplied (or the base Frame
*     if a FrameSet was supplied) is not 2-dimensional.
*     - A null Object pointer (AST__NULL) will be returned if this
c     function is invoked with the AST error status set, or if it
f     function is invoked with STATUS set to an error value, or if it
*     should fail for any reason.
*--

*  Implementation Notes:
*     - This function implements the external (public) interface to
*     the astPlot constructor function. It returns an ID value
*     (instead of a true C pointer) to external users, and must be
*     provided because astPlot_ has a variable argument list which
*     cannot be encapsulated in a macro (where this conversion would
*     otherwise occur).
*     - Because no checking or casting of arguments is performed
*     before the function is invoked, the "frame" parameter is of type
*     (void *) and is converted from an ID value to a pointer and
*     validated within the function itself.
*     - The variable argument list also prevents this function from
*     invoking astPlot_ directly, so it must be a
*     re-implementation of it in all respects, except for the
*     conversions between IDs and pointers on input/output of Objects.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstFrame *frame;              /* Pointer to Frame structure */
   AstPlot *new;                 /* Pointer to new Plot */
   va_list args;                 /* Variable argument list */
   int *status;                  /* Pointer to inherited status value */

/* Get apointer to the inherited status value. */
   status = astGetStatusPtr;

/* Check the global status. */
   if ( !astOK ) return NULL;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Initialise variables to avoid "used of uninitialised variable"
   messages from dumb compilers. */
   new = NULL;

/* Obtain a Frame pointer from any ID supplied and validate the
   pointer to ensure it identifies a valid Frame. */
   if( frame_void ){
      frame = astVerifyFrame( astMakePointer( frame_void ) );
   } else {
      frame = NULL;
   }

/* Check the pointer can be used. */
   if ( astOK ) {

/* Initialise the Plot, allocating memory and initialising the
   virtual function table as well if necessary. */
      new = astInitPlot( NULL, sizeof( AstPlot ), !class_init,
                         &class_vtab, "Plot", frame, graphbox,
                         basebox );

/* If successful, note that the virtual function table has been
   initialised. */
      if ( astOK ) {
         class_init = 1;

/* Obtain the variable argument list and pass it along with the
   options string to the astVSet method to initialise the new
   Plot's attributes. */

         va_start( args, options );
         astVSet( new, options, NULL, args );
         va_end( args );

/* If an error occurred, clean up by deleting the new object. */
         if ( !astOK ) new = astDelete( new );
      }
   }

/* Return an ID value for the new Plot. */
   return astMakeId( new );

}