1265 lines
45 KiB
Plaintext
1265 lines
45 KiB
Plaintext
|
|
_texpict_ is a Racket/GRacket library for creating pictures using a
|
|
GRacket dc<%> (including post-script-dc% for _PostScript_ output) or
|
|
_LaTeX_ as the back-end. The two back-ends are incompatible; picts
|
|
must be created for one or the other. The library was originally
|
|
designed for LaTeX output, hence the name.
|
|
|
|
Pictures are created as `pict' structures. Some procedures in the
|
|
texpict library create new simple picts (e.g., `hline'). Others build
|
|
new picts out of existing picts (e.g., `ht-append'). In the latter
|
|
case, the embedded picts retain their identity, so that offset-finding
|
|
functions (e.g., `lt-find') can find the offset of an embedded pict in
|
|
a larger pict.
|
|
|
|
A pict has the following structure:
|
|
w
|
|
------------------
|
|
| | a \
|
|
|------------------| |
|
|
| | | h
|
|
|------------------| |
|
|
| | d /
|
|
------------------
|
|
|
|
For a single text line, d is descent below the baseline and
|
|
a + d = h. For multiple text lines (created with vX-append), a is
|
|
ascent of top line above baseline and d is descent of bottom line,
|
|
so a + d < h. Most other boxes have d = 0 and a = h.
|
|
|
|
The size information for a pict is computed when the pict is
|
|
created. This strategy supports programs that create new picts though
|
|
arbitrarily complex computations on the size and shape of existing
|
|
picts. However, it also means that a pict cannot be generated before
|
|
its target device is known.
|
|
|
|
A slightly different set of picture-making function are available for
|
|
GRacket and LaTeX output. For example, the LaTeX set includes `tex',
|
|
which accepts a string of arbitrary LaTeX code, and the GRacket set
|
|
includes `dc', which accepts an arbitrary Scheme procedure for drawing
|
|
to a dc<%>.
|
|
|
|
When creating pictures with the obsolete `picture' or `cons-picture'
|
|
functions, or when finding relative picture locations with the
|
|
obsolete `find-lt', etc., the coordinate system is upside-down: (0, 0)
|
|
is in the lower left.
|
|
|
|
Slideshow output
|
|
----------------
|
|
|
|
Slideshow (see the "slideshow" collection) takes care of configuring
|
|
texpict and rendering them to the screen or printer. In particular,
|
|
the `slide' function takes any number of picts and assembles them into
|
|
a slide.
|
|
|
|
If you are using Slideshow, skip the following two sections. In the
|
|
reference below, functions marked "GRacket only" or "GRacket only, in
|
|
utils.ss" are available, and functions marked "LaTeX only" are not
|
|
available.
|
|
|
|
For non-Slideshow users, _utils.ss_ library provides additional
|
|
drawing procedures for GRacket (not LaTeX) output. These are marked below
|
|
with "GRacket only, in utils.ss".
|
|
|
|
|
|
GRacket (or PostScript) output
|
|
---------------------------
|
|
|
|
The GRacket texpict function set is loaded by the _mrpict.ss_ library.
|
|
The library is available in unit form via _mrpict-unit.ss_, which
|
|
exports a `mrpict@' unit that imports draw^ and exports
|
|
`texpict-common^' and `mrpict-extra^'. The _mrpict-sig.ss_ library
|
|
file provides both signatures.
|
|
|
|
When creating a picture for a GRacket dc<%> that contains text, texpict
|
|
needs a drawing context for measuring the text. Provide a dc<%> before
|
|
constructing pictures via the `dc-for-text-size' parameter. The dc<%>
|
|
should have the same text-measuring results as the destination dc<%>;
|
|
in particular, use a post-script-dc% for preparing PostScript output,
|
|
and a bitmap-dc% will work fine for bitmap-dc% or canvas% output.
|
|
|
|
The `draw-pict' function takes a picture, a device context
|
|
|
|
;; Example of producing PostScript output
|
|
(require texpict/mrpict)
|
|
|
|
;; Create PS context
|
|
(define ps-dc (make-object post-script-dc%))
|
|
(send ps-dc start-doc "Pict output")
|
|
(send ps-dc start-page)
|
|
|
|
;; Install context for sizing
|
|
(dc-for-text-size ps-dc)
|
|
|
|
;; Create the pict
|
|
(define p ...)
|
|
|
|
;; Output pict
|
|
(draw-pict p ps-dc 0 0)
|
|
(send ps-dc end-page)
|
|
(send ps-dc end-doc)
|
|
|
|
If the output dc<%> has a "user scale", it is not reflected in the
|
|
size information reported for pictures. This is consistent with GRacket's
|
|
usual policy for reporting size information.
|
|
|
|
LaTeX output
|
|
------------
|
|
|
|
The LaTeX texpict function set is loaded by the _texpict_ library.
|
|
The library is available in unit form via _texpict-unit.ss_, which
|
|
provides a `texpict@' unit with no imports and that exports
|
|
`texpict-common^' and `texpict-extra^'. The _texpict-sig.ss_ library
|
|
provides both signatures.
|
|
|
|
Pictures created with this library are incompatible with Slideshow
|
|
and GRacket-based output.
|
|
|
|
To create a LaTeX picture, assemble a pict and then
|
|
call `pict->string'. This string can be `display'ed to obtain the
|
|
LaTeX code, which is usually of the form:
|
|
\begin{picture} ... \end{picture}
|
|
When using colors, the output may be of the form:
|
|
\special{color push ...} ... \special{color pop ...}
|
|
so consider putting the output in an \hbox{} when using color.
|
|
|
|
The `tex' function creates a pict given an arbitrary LaTeX
|
|
expression as a string. Initially, `tex' guess at the size of the
|
|
resulting pict. (It always guesses 10 x 10.) The LaTeX expression
|
|
generated for a `tex' pict causes information to be written to an
|
|
auxiliary file when LaTeX evaluates the expression. If you use
|
|
`tex' boxes, then:
|
|
|
|
* Use the package "mztp.sty" at the start of your LaTeX
|
|
document "X.tex".
|
|
* In the Racket code creating `tex' picts, call
|
|
(read-in-sizes "X.mztp") before calling `tex'.
|
|
* Run the texpict-LaTeX cycle twice to get properly
|
|
draw pictures.
|
|
|
|
texpict keys `tex' size information on the exact LaTeX expression
|
|
provided to `tex'. If you use a single `tex' pict in two different
|
|
contexts where the provided expression produces differently sized
|
|
output, texpict will not distinguish the uses (and the size of the
|
|
first instance of the pict will be used) by default. The
|
|
`serialize-tex-picts' parameter can solve this problem, but
|
|
serialization requires that the output is built in exactly the same
|
|
order every time, and generally requires more texpict-tex cycles to
|
|
reach a fixed point after a small change to the output. The
|
|
`tex-series-prefix' parameter may be used to explicitly tag `tex'
|
|
sequences in different contexts.
|
|
|
|
For LaTeX output, all positions and sizes must be specified as exact
|
|
integers, but texpict does not check that exact integers are supplied.
|
|
|
|
------------------------------------------------------------
|
|
Structures
|
|
------------------------------------------------------------
|
|
|
|
A pict is an instance of the `pict' structure type:
|
|
|
|
> struct:pict :: (struct pict (draw width height ascent descent children panbox))
|
|
|
|
The `children' field is a list of `child' structures:
|
|
|
|
> struct:child :: (struct child (pict dx dy sx sy))
|
|
|
|
------------------------------------------------------------
|
|
Procedures
|
|
------------------------------------------------------------
|
|
|
|
Basic Constructors:
|
|
-------------------
|
|
|
|
> (dc draw-proc w h) -> pict
|
|
> (dc draw-proc w h a d) -> pict
|
|
where draw proc is (dc x y -> void)
|
|
|
|
Creates an arbitrary self-rendering pict. The arguments to the
|
|
rendering procedure will be a device context and top-left
|
|
location for drawing.
|
|
|
|
When the rendering procedure is called, the current pen and
|
|
brush will be solid and in the pict's color (and linewidth), and
|
|
the scale and offset of the dc will be set. The text mode will
|
|
be transparent, but the font and colors are not guaranteed to be
|
|
anything in particular.
|
|
[GRacket only]
|
|
|
|
> (blank) -> pict
|
|
> (blank s) -> pict ; s is side length of square
|
|
> (blank w h) -> pict
|
|
> (blank w a d) -> pict ; => h = a + d
|
|
> (blank w g a d) -> pict
|
|
|
|
Creates an empty pict
|
|
|
|
> (text string [text-style null] [size 12] [angle 0]) -> pict
|
|
|
|
Creates a pict from a string, style, size, and rotation.
|
|
A _text-style_ is one of
|
|
null (the default, same a 'default),
|
|
a font% object,
|
|
a font family symbol (e.g., 'roman),
|
|
a font face string (e.g., "-adobe-symbol"),
|
|
`(bold . ,text-style),
|
|
`(italic . ,text-style),
|
|
`(subscript . ,text-style),
|
|
`(superscript . ,text-style),
|
|
`(combine . ,text-style), or
|
|
`(no-combine . ,text-style).
|
|
`(caps . ,text-style).
|
|
A size is an exact number in [1, 255] in pixels; the
|
|
default size is 12, but the size is ignored if
|
|
a font% object is provided in the text-style.
|
|
The default rotation is 0; for a non-zero rotation,
|
|
the pict covers the rotated text, and the descent
|
|
is zero and the ascent is the height
|
|
By default, text drawing can combine characters (to
|
|
form ligatures, for kerning, etc.), unless the
|
|
base text-style is 'modern. The 'combine text-style symbol
|
|
overrides the default to allow combining, and the
|
|
'no-combine text-style symbol overrides the default to
|
|
disable combining; if both 'combine and 'no-combine
|
|
are specified, the first one takes precedence
|
|
If caps is specified, the angle must be zero.
|
|
[GRacket only]
|
|
|
|
> text-style/c :: contract?
|
|
|
|
This is a contract that matches the second argument of `text'.
|
|
|
|
> (caps-text string [text-style null] [size 12] [angle 0]) -> pict
|
|
|
|
Same as `text', but use small caps:
|
|
|
|
> (hline w h) -> pict
|
|
> (dash-hline w h seg-length) -> pict ; default seg-length is 5
|
|
> (vline w h) -> pict
|
|
> (dash-vline w h seg-length) -> pict ; default seg-length is 5
|
|
|
|
To draw other kinds of lines, use `dc' [GRacket only] or `picture' or
|
|
`cons-picture' [LaTeX].
|
|
|
|
> (frame pict) -> pict
|
|
> (dash-frame pict seg-length) -> pict ; default seg-length is 5
|
|
> (oval pict) -> pict
|
|
> (oval/radius pict r) -> pict ; r is radius of corners
|
|
|
|
> (big-circle diameter) -> pict
|
|
|
|
Creates a fairly round circle using four splines (intended
|
|
for LaTeX output)
|
|
|
|
> (color-frame pict color-string) -> pict
|
|
> (color-frame pict color-string line-w) -> pict
|
|
> (color-dash-frame pict seg-length color-string) -> pict
|
|
> (color-dash-frame pict seg-length color-string line-w) -> pict
|
|
|
|
Like `frame' and `dash-frame', but the frame gets a color and
|
|
optional line width
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (round-frame pict radius-w) -> pict
|
|
> (color-round-frame pict radius-w color-string) -> pict
|
|
> (color-round-frame pict radius-w color-string line-w) -> pict
|
|
|
|
Rounded frames, given a radius for the corners
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (circle diameter) -> pict
|
|
> (disk diameter) -> pict
|
|
|
|
Unfilled and filled circles; works for all sizes.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (ellipse width height) -> pict
|
|
> (filled-ellipse width height) -> pict
|
|
|
|
Unfilled and filled ellipses; works for all sizes.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (rectangle width height) -> pict
|
|
> (filled-rectangle width height) -> pict
|
|
|
|
Unfilled and filled rectangle; works for all sizes.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (rounded-rectangle width height [corner]) -> pict
|
|
> (filled-rounded-rectangle width height [corner]) -> pict
|
|
|
|
Unfilled and filled rounded rectangle; works for all sizes.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (arrow size radians) -> pict
|
|
> (arrowhead size radians) -> pict
|
|
|
|
Creates an arrow or arrowhead in the specific direction
|
|
within a size x size pict. (Points on the arrow may
|
|
extend slightly beyond the box.)
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (pip-line dx dy size) -> pict
|
|
> (pip-arrow-line dx dy size) -> pict
|
|
> (pip-arrows-line dx dy size) -> pict
|
|
|
|
Creates a line [with arrowhead(s)] as a 0-sized picture suitable
|
|
for use with `pin-over'. The 0-sized picture contains the starting
|
|
point.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (bitmap filename) -> pict
|
|
> (bitmap bitmap%-object) -> pict
|
|
|
|
Loads a bitmap into a pict; if the bitmap is not ok,
|
|
the result is a box containing the words "bitmap failed"
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (cloud w h [color-string "gray"]) -> pict
|
|
|
|
Fluffy cloud.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (file-icon w h gray [fancy? ...]) -> pict
|
|
|
|
Creates a MacOS-like file icon, optionally shaded.
|
|
Default for `fancy?': gray = #f -> white
|
|
gray = #t -> default color
|
|
gray = color/string -> uses color
|
|
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (jack-o-lantern size [pumpkin-color "orange"] [face-color "black"]) -> pict
|
|
|
|
Creates a jack-o-lantern; use the same pumpkin-color and
|
|
face color to get a plain pumpkin. The size is the width.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (angel-wing w h left?) -> pict
|
|
|
|
Creates an angel wing, left or right, or any size.
|
|
The color and pen width for drawing the wing outline is the
|
|
current one.
|
|
[GRacket only, in utils.ss]
|
|
|
|
|
|
> (standard-fish w h [direction 'left] [color "blue"]
|
|
[eye-color "black"] [open-mouth? #t]) -> pict
|
|
|
|
Creates a fish, swimming either 'left or 'right.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (explode-star small-rad large-rad points line-size line-color)
|
|
|
|
Creates a star-shaped explosion thingy. The points are
|
|
aligned on two radii, one for the beginning of the points
|
|
and one for the end, large-rad and small-rad. points is
|
|
the number of spikes sitcking out, and line-size and
|
|
line-color are the thickness of the lines and the lines
|
|
color.
|
|
|
|
|
|
Combiners:
|
|
----------
|
|
|
|
> (vl-append [d 0] pict ...) -> pict ; d units between each picture
|
|
> (vc-append [d 0] pict ...) -> pict
|
|
> (vr-append [d 0] pict ...) -> pict
|
|
> (ht-append [d 0] pict ...) -> pict
|
|
> (hc-append [d 0] pict ...) -> pict
|
|
> (hb-append [d 0] pict ...) -> pict
|
|
> (htl-append [d 0] pict ...) -> pict ; align bottoms of ascents
|
|
> (hbl-append [d 0] pict ...) -> pict ; align tops of descents (normal text alignment)
|
|
|
|
Make a new picture as a column (vX-append) or row (hX-append)
|
|
of other pictures. Different procedures align pictures in the
|
|
orthogonal direction in different ways; e.g, vl-append left-aligns
|
|
all of the pictures. A specified amount of space is inserted
|
|
between each pair of pictures in making the column or row.
|
|
The descent of the result corresponds to baseline that is lowest
|
|
in the result among all of the picts' descent-specified
|
|
baselines; similarly, the ascent of the result corresponds to
|
|
the highest ascent-specified baseline.
|
|
|
|
> (lt-superimpose pict ...) -> pict
|
|
> (lb-superimpose pict ...) -> pict
|
|
> (lc-superimpose pict ...) -> pict
|
|
> (ltl-superimpose pict ...) -> pict
|
|
> (lbl-superimpose pict ...) -> pict
|
|
> (rt-superimpose pict ...) -> pict
|
|
> (rb-superimpose pict ...) -> pict
|
|
> (rc-superimpose pict ...) -> pict
|
|
> (rtl-superimpose pict ...) -> pict
|
|
> (rbl-superimpose pict ...) -> pict
|
|
> (ct-superimpose pict ...) -> pict
|
|
> (cb-superimpose pict ...) -> pict
|
|
> (cc-superimpose pict ...) -> pict
|
|
> (ctl-superimpose pict ...) -> pict
|
|
> (cbl-superimpose pict ...) -> pict
|
|
|
|
Make a new picture by superimposing a set of pictures. The
|
|
alignment indicators are essentially as above: horizontal
|
|
alignment then vertical alignment. The descent and the ascent
|
|
of the result is also computed as above (i.e., lowest descent
|
|
and highest ascent).
|
|
|
|
> (pin-over pict dx dy pict) -> pict
|
|
> (pin-over pict sub-pict find-proc pict) -> pict
|
|
|
|
Creates a pict with the same bounding box, ascent, and descent
|
|
as the initial argument, but with the second pict placed on top.
|
|
The dx and dy argument specify how far right and down the second
|
|
pict's corner is from the first pict's corner.
|
|
Alternately, the sub-pict and procedure arguments find a point
|
|
in the initial pict for the second pict's corner. The procedure
|
|
should be like lt-find.
|
|
|
|
> (pin-under pict dx dy pict) -> pict
|
|
> (pin-under pict sub-pict find-proc pict) -> pict
|
|
|
|
Like pin-over, but the second pict is drawn first, then the
|
|
initial pict.
|
|
|
|
> (table ncols pict-list col-aligns row-aligns col-seps row-seps) -> pict
|
|
|
|
Make a table given a list of picts. The list is a
|
|
concatenation of rows (which means that a Scheme `list' call
|
|
can be formatted to reflect the shape of the output table).
|
|
|
|
The col-aligns, row-aligns, col-seps, and row-seps arguments are
|
|
`lists' specifying the row and columns alignments separation
|
|
between rows and columns. For C columns and R rows, the first
|
|
two should have C and R superimpose procedures, and the last two
|
|
should have C - 1 and R - 1 numbers, respectively. The lists can
|
|
be improper (e.g. just a number), in which case the non-pair cdr
|
|
is used as the value for all remaining list items that were
|
|
expected. The alignment procedures are used to superimpose all
|
|
of the cells in a column or row; this superimposition determines
|
|
the total width or height of the column or row, and also
|
|
determines the horizontal or vertical placement of each cell in
|
|
the column or row.
|
|
|
|
> (record pict pict ...) -> pict
|
|
|
|
Make a UML-like record picture, where the
|
|
first argument is the title and the rest are fields.
|
|
|
|
|
|
Drawing Adjusters:
|
|
------------------
|
|
|
|
> (scale pict factor) -> pict
|
|
> (scale pict x-factor y-factor) -> pict
|
|
|
|
Scales a pict (by adjusting the destination dc<%>'s
|
|
scale while drawing the pict.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (ghost pict) -> pict
|
|
|
|
Make a container picture that doesn't draw the child picture,
|
|
but uses the child's size
|
|
|
|
> (thick pict) -> pict
|
|
> (thin pict) -> pict
|
|
|
|
Set the line thickness for a picture. For GRacket output,
|
|
selects between a pen width of 0 or 1.
|
|
|
|
> (linewidth w pict) -> pict
|
|
|
|
Set a specific pen width for drawing.
|
|
[GRacket only]
|
|
|
|
> (colorize pict color-string) -> pict
|
|
|
|
Apply a color to a picture. If the given picture has a colorized
|
|
sub-picture, the color of the sub-picture is not affected.
|
|
[LaTeX: use the LaTeX package "colordvi"]
|
|
|
|
> (colorize pict color%) -> pict
|
|
|
|
Same as above, except uses the color% object instead of a string
|
|
to indicate the color of the pict.
|
|
[GRacket only]
|
|
|
|
> (colorize pict num-list) -> pict
|
|
|
|
Same as above, except the list of three numbers indicate the
|
|
red, green, and blue components of the color.
|
|
[GRacket only]
|
|
|
|
> (cellophane pict opacity) -> pict
|
|
|
|
Makes the given pict semi-transparent, where an opacity of 0.0 is
|
|
fully transparent, and an opacity of 1.0 is fully opaque. See
|
|
`set-alpha' of dc<%> for information about the contexts and cases
|
|
when semi-transparent drawing works.
|
|
|
|
> (clip pict)
|
|
|
|
Clips a pict to its bounding box.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (scale/improve-new-text pict-expr s-expr)
|
|
> (scale/improve-new-text pict-expr sx-expr sy-expr)
|
|
|
|
Syntax that is like `scale', but also sets
|
|
`current-expected-text-scale' while evaluating
|
|
`pict-expr':
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (inset/clip pict amt)
|
|
> (inset/clip pict h-amt v-amt)
|
|
> (inset/clip pict l-amt t-amt r-amt b-amt)
|
|
|
|
Insets and clips the pict's drawing to its
|
|
bounding box. (Usually the inset amounts are negative.)
|
|
[GRacket only, in utils.ss]
|
|
|
|
|
|
Bounding-Box Adjusters:
|
|
-----------------------
|
|
|
|
> (inset pict i) -> pict
|
|
> (inset pict hi vi) -> pict
|
|
> (inset pict li ti ri bi) -> pict
|
|
|
|
Extends picture size by adding the give amounts to the
|
|
corresponding side; ascent and descent are extended, too.
|
|
|
|
> (clip-descent pict) -> pict
|
|
|
|
Truncates picture, removing descent part.
|
|
|
|
> (lift pict n) -> pict
|
|
|
|
Lifts picture relative to its baseline, extending
|
|
the height if necessary
|
|
|
|
> (drop pict n) -> pict
|
|
|
|
Drops picture below its ascent line, extending
|
|
the height if necessary
|
|
|
|
> (baseless pict) -> pict
|
|
|
|
Makes the descent 0 and the ascent the height
|
|
|
|
> (refocus pict pict) -> pict
|
|
|
|
Given a pict and an embedded pict, shifts the
|
|
given pict's bounding box to that of the
|
|
embedded pict
|
|
|
|
> (panorama pict) -> pict
|
|
|
|
Given a pict, shifts the given pict's bounding box
|
|
to enclose the bounding boxes of all sub-picts
|
|
(laundered or not)
|
|
|
|
|
|
Finders:
|
|
--------
|
|
|
|
> (lt-find pict pict-path) -> dx dy
|
|
> (lc-find pict pict-path) -> dx dy
|
|
> (lb-find pict pict-path) -> dx dy
|
|
> (ltl-find pict pict-path) -> dx dy
|
|
> (lbl-find pict pict-path) -> dx dy
|
|
> (rt-find pict pict-path) -> dx dy
|
|
> (rc-find pict pict-path) -> dx dy
|
|
> (rb-find pict pict-path) -> dx dy
|
|
> (rtl-find pict pict-path) -> dx dy
|
|
> (rbl-find pict pict-path) -> dx dy
|
|
> (ct-find pict pict-path) -> dx dy
|
|
> (cc-find pict pict-path) -> dx dy
|
|
> (cb-find pict pict-path) -> dx dy
|
|
> (ctl-find pict pict-path) -> dx dy
|
|
> (cbl-find pict pict-path) -> dx dy
|
|
|
|
Finds an embedded picture.
|
|
A pict-path is either
|
|
pict
|
|
non-empty-pict-path-list
|
|
|
|
> (launder pict) -> pict
|
|
|
|
Creates a new pict that hides the given pict from XX-find
|
|
|
|
|
|
Other constructors:
|
|
-------------------
|
|
|
|
> pin-line ; pict
|
|
; src-pict (pict pict -> x y)
|
|
; dest-pict (pict pict -> x y)
|
|
; [line-w [color-string [lines-under?]]]
|
|
; -> pict
|
|
> pin-arrow-line ; arrow-size pict
|
|
; src-pict (pict pict -> x y)
|
|
; dest-pict (pict pict -> x y)
|
|
; [line-w [color-string [lines-under? [solid-head?]]]]
|
|
; -> pict
|
|
> pin-arrows-line ; arrow-size pict
|
|
; src-pict (pict pict -> x y)
|
|
; dest-pict (pict pict -> x y)
|
|
; [line-w [color-string [lines-under? [solid-head?]]]]
|
|
; -> pict
|
|
|
|
Adds a line or line-with-arrows onto a pict, using
|
|
one of the sub-pict-finding functions (e.g., `lt-find')
|
|
to extract the source and destination of the line.
|
|
|
|
The defaults for line-w, color-string, and lines-under?
|
|
are #f, and the default for solid-head? is #t.
|
|
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (hyperlinkize pict) -> pict
|
|
|
|
Adds an underline and blue color. The pict's
|
|
height and descent are extended.
|
|
[GRacket only, in utils.ss]
|
|
|
|
|
|
Renderers:
|
|
----------
|
|
|
|
> (show-pict pict [w #f] [h #f]) -> void
|
|
|
|
Opens a frame that displays the pict.
|
|
The frame adds one method:
|
|
set-pict : pict -> void
|
|
that changes the visible pict.
|
|
the optional w and h arguments must
|
|
be either numbers of #f. If numbers,
|
|
the window is at least that size
|
|
and the pict is drawn in the middle of
|
|
the window.
|
|
[GRacket only]
|
|
|
|
> (draw-pict pict dc x y) -> void
|
|
|
|
Draw a pict to a dc<%>
|
|
[GRacket only]
|
|
|
|
> (make-pict-drawer pict) -> ((dc x y) -> void)
|
|
|
|
Generate a pict-drawer procedure for multiple renderings of a
|
|
pict (much faster than repeated calls to draw-pict)
|
|
[GRacket only]
|
|
|
|
|
|
GRacket DC Helpers:
|
|
----------------
|
|
|
|
> (scale-color factor string-or-color%) -> color%
|
|
|
|
Scales a color, making it brighter or darker. If the
|
|
factor is < 1, the color is darkened by multiplying
|
|
the RGB components by the factor. If the factor is > 1,
|
|
the color is lightened by dividing the gap between
|
|
the RGB components and 255 by the factor.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (find-pen string-or-color% [size 1] [style 'solid]) -> pen%
|
|
|
|
Gets an immutable pen% from the-pen-list
|
|
[GRacket only, in utils.ss]
|
|
|
|
> (find-brush string-or-color% [style 'solid]) -> brush%
|
|
|
|
Gets an immutable brush from the-brush-list
|
|
[GRacket only, in utils.ss]
|
|
|
|
> color-series ; dc<%> num-steps step-delta
|
|
; start-color-or-string%
|
|
; end-color-or-string%
|
|
; (num -> any)
|
|
; set-pen? set-brush? -> void
|
|
|
|
Calls a drawing function multiple times, gradually
|
|
changing the pen/brush color for each call. The
|
|
step count and step delta should be exact numbers;
|
|
the procedure is called with each number from 0 to
|
|
the step count, using the step delta. For the first
|
|
call, the current pen and/or brush color matches the
|
|
starting color; for the last call, it matches the
|
|
ending color; and for intermediate calls, the color
|
|
is an intermediate color.
|
|
[GRacket only, in utils.ss]
|
|
|
|
------------------------------------------------------------
|
|
Additional LaTex Utilities
|
|
------------------------------------------------------------
|
|
|
|
> (tex string) -> pict
|
|
> (text-line string) -> pict
|
|
> (text-line/phantom string string) -> pict
|
|
> (tex-paragraph w string ['top|'bottom]) -> pict
|
|
|
|
Create picts from LaTeX code
|
|
[LaTeX only]
|
|
|
|
> (left-brace h) -> pict
|
|
> (right-brace h) -> pict
|
|
> (left-delimit str h) -> pict
|
|
> (right-delimit str h) -> pict
|
|
> (middle-delimit str h) -> pict
|
|
> (top-brace w) -> pict
|
|
> (bottom-brace w) -> pict
|
|
|
|
Delimiters to go around height h (result is taller than h;
|
|
try h/2)
|
|
Delimiter to go around width w (result is w wide)
|
|
[LaTeX only]
|
|
|
|
> (pict->string pict) -> string
|
|
|
|
Generate the LaTeX code for a pict.
|
|
[LaTeX only]
|
|
|
|
------------------------------------------------------------
|
|
GRacket and LaTex Setup
|
|
------------------------------------------------------------
|
|
|
|
> dc-for-text-size
|
|
|
|
Parameter specifying the dc<%> to use for measuring text.
|
|
Default: #f
|
|
[GRacket only]
|
|
|
|
> current-expected-text-scale ; -> (list num num)
|
|
; (list num num) -> void
|
|
|
|
A parameter used to refine text measurements to better
|
|
match an expected scaling of the image.
|
|
Default: 1
|
|
[GRacket only]
|
|
|
|
> (read-in-sizes string) -> void
|
|
|
|
Load `tex' pict size information generated by a LaTeX run.
|
|
[LaTeX only]
|
|
|
|
> output-measure-commands
|
|
|
|
Parameter specifying whether to produce LaTeX commands to
|
|
produce size information for a future run.
|
|
Default: #t
|
|
[LaTeX only]
|
|
|
|
> using-pict2e-package
|
|
|
|
Parameter specifying whether the `pict2e' package is active.
|
|
Default: #f
|
|
[LaTeX only]
|
|
|
|
> draw-bezier-lines
|
|
|
|
Parameter specifying whether to draw precise lines for `connect'
|
|
with bezier curves. The value is a Boolean or a procedure that
|
|
takes a length and returns the number of points to use.
|
|
Default: #f
|
|
[LaTeX only]
|
|
|
|
> use-old-connect
|
|
|
|
Parameter to use the old implementation of `connect'.
|
|
Default: #f
|
|
[LaTeX only]
|
|
|
|
> tex-series-prefix
|
|
|
|
Parameter specifying a string to embed in the sizing key for a
|
|
pict created with `tex'. The prefix is applied when the `tex'
|
|
pict is created. Turning on the `serialize-tex-picts' parameter
|
|
effectively generates a new series prefix for every `tex' pict.
|
|
Default: #f
|
|
[LaTeX only]
|
|
|
|
> serialize-tex-picts
|
|
|
|
Parameter specifying whether to assign serial numbers to
|
|
`tex'-generated strings for sizing purposes. Serial numbers
|
|
allow the same tex string to be used in multiple contexts, but
|
|
the output must be built in the same order every time.
|
|
Default: #f
|
|
[LaTeX only]
|
|
|
|
> black-and-white
|
|
|
|
Parameter specifying whether to draw in B&W or color (when
|
|
`colorize' is used).
|
|
Default: #f
|
|
|
|
------------------------------------------------------------
|
|
Obsolete functions
|
|
------------------------------------------------------------
|
|
|
|
> (picture w h command-list) -> pict
|
|
|
|
Obsolete: describes a picture with low-level commands; see below.
|
|
|
|
> (cons-picture pict command-list) -> pict
|
|
> (cons-picture* pict command-list) -> pict
|
|
|
|
Create a new picture by `cons'ing drawing commands onto
|
|
an existing picture. `cons-picture*' maintains the pict's
|
|
descent and ascent.
|
|
|
|
> (cons-colorized-picture pict color-string command-list) -> pict
|
|
|
|
Like `cons-picture', but the newly consed commands get a
|
|
color
|
|
|
|
> (place-over pict dx dy pict) -> pict
|
|
> (place-over pict sub-pict find-proc pict) -> pict
|
|
|
|
Obsolete versions of `pin-over', where a procedure is expected
|
|
to return a flipped y value, like find-lt.
|
|
|
|
> (place-under pict dx dy pict) -> pict
|
|
> (place-under pict sub-pict find-proc pict) -> pict
|
|
|
|
Like `place-over', but the second pict is drawn first, then the
|
|
initial pict.
|
|
|
|
> find-lt
|
|
> find-lc
|
|
> find-lb
|
|
> find-ltl
|
|
> find-lbl
|
|
> find-ct
|
|
> find-cc
|
|
> find-cb
|
|
> find-ctl
|
|
> find-cbl
|
|
> find-rt
|
|
> find-rc
|
|
> find-rb
|
|
> find-rtl
|
|
> find-rbl
|
|
|
|
Obsolete versions of ...-find, where the result y is flipped
|
|
|
|
> (arrow-line dx dy size) -> pict
|
|
> (arrows-line dx dy size) -> pict
|
|
|
|
Obsolete versions of the `line+arrow[s]' functions,
|
|
where the vertical delta is negated.
|
|
[GRacket only, in utils.ss]
|
|
|
|
> add-line
|
|
> add-arrow-line
|
|
> add-arrows-line
|
|
|
|
Obsolete variants of the pin-...line functions
|
|
where the pict-finding functions are like `find-lt' (i.e.,
|
|
the y result is flipped)
|
|
[GRacket only, in utils.ss]
|
|
|
|
------------------------------------------------------------
|
|
Obsolete: Commands, Putables, and Drawables
|
|
------------------------------------------------------------
|
|
|
|
Commands:
|
|
---------
|
|
|
|
These commands use LaTeX-style coordinates: bottom-left
|
|
is (0, 0).
|
|
|
|
The varieties of `connect' commands are for LaTeX, where
|
|
lines are constrained to a small set of allowed angles.
|
|
For GRacket, all of the commands below act the same, and produce
|
|
lines with precisely the requested angle.
|
|
|
|
A command is one of the following:
|
|
`(place ,x ,y ,pict)
|
|
`(put ,x ,y ,putable)
|
|
|
|
|
|
`(connect ,x1 ,y1 ,x2 ,y2 ,bool) ; line or vector; bool => vector;
|
|
; from (x1,y1) to (~x2,~y2)
|
|
; as close as possible
|
|
; (synonym for connect~xy with
|
|
; an infinite tolerance when
|
|
; draw-bezier-lines is #f, or
|
|
; for curve when draw-bezier-lines
|
|
; is #t)
|
|
`(dconnect ,x ,y ,dx ,dy ,bool) ; line or vector; bool => vector;
|
|
; from (x,y) to (~(x+dx),~(y+dy))
|
|
; as close as possible (uses
|
|
; connect)
|
|
`(connect~y ,tol ,x1 ,y2 ,x2 ,y2 ,bool) ; sequence of lines from
|
|
; (~x1,~y1) to (~x2,~y2) where
|
|
; either:
|
|
; 1) ~x2=x2 and |~y2-y2|<tol
|
|
; 2) ~y2=y2 and |~x2-x2|<tol and
|
|
; the final line is vertical
|
|
`(connect~x ,tol ,x1 ,y2 ,x2 ,y2 ,bool) ; like connect~y, but either:
|
|
; 1) ~x2=x2 and |~y2-y2|<tol
|
|
; the final line is horizontal
|
|
; 2) ~y2=y2 and |~x2-x2|<tol
|
|
`(connect~xy ,tol ,x1 ,y2 ,x2 ,y2 ,bool) ; like connect~y, but either:
|
|
; 1) ~x2=x2 and |~y2-y2|<tol
|
|
; the final line is horizontal
|
|
; 2) ~y2=y2 and |~x2-x2|<tol
|
|
; the final line is vertical
|
|
; 3) |(x2,y2)-(~x2,~y2)|<tol
|
|
`(curve ,x1 ,y1 ,x2 ,y2 ,xc ,yc ,d) ; bezier curve; d is optional density
|
|
; for LaTeX; the default d is 1.0
|
|
|
|
[Notes: curve can generate more precise lines than connect~, but it usually
|
|
requires more LaTeX memory.]
|
|
|
|
Putables:
|
|
---------
|
|
|
|
A putable is one of the following:
|
|
draw
|
|
`(line ,dh ,dv ,hlen) ; LaTeX-style line - slope and size is limited
|
|
`(vector ,dh ,dv ,hlen) ; LaTeX-style vector - slope and size is limited
|
|
`(circle ,d) ; LaTeX-style circle - size is limited
|
|
`(circle* ,d)
|
|
`(frame ,draw)
|
|
`(colorbox ,color-str ,draw)
|
|
`(oval ,str ,w ,h) ; str is portion a la LaTeX: e.g., "" or "[bl]";
|
|
; the oval is centered at the put position, instead of
|
|
; bl-aligned
|
|
; plus some more undocumented ones...
|
|
|
|
Draws:
|
|
------
|
|
|
|
A draw is one of the following:
|
|
string ; latex string
|
|
`(picture ,w ,h ,@command-list)
|
|
`(color ,color-string ,draw)
|
|
`(thickness ,thickness ,draw) ; thickness is thicklines or thinlines
|
|
|
|
------------------------------------------------------------
|
|
_slideshow-run.ss_ and _slideshow.ss_
|
|
------------------------------------------------------------
|
|
|
|
The "slideshow-run.ss" and "slideshow.ss" modules simply re-export
|
|
`slideshow/run' and `slideshow/slideshow'
|
|
for backward compatibility.
|
|
|
|
See the "slideshow" collection for more details.
|
|
|
|
------------------------------------------------------------
|
|
_balloon.ss_
|
|
------------------------------------------------------------
|
|
|
|
The "balloon.ss" module produce functions for creating and placing
|
|
cartoon-speech balloons.
|
|
|
|
> (wrap-balloon pict spike-sym dx dy [color corner-radius])
|
|
|
|
Superimposes `pict' on top of a balloon that wraps it.
|
|
|
|
The `spike-sym' indicates the corner from which a spike protrudes from
|
|
the balloon (i.e., the spike that points to whatever the balloon is
|
|
about). It's one of 'n, 's, 'e, 'w, 'ne, 'se, 'sw, or 'nw.
|
|
|
|
The `dx' and `dy' arguments specify how far the spike should protrude.
|
|
For a 'w spike, `dx' should be negative, etc.
|
|
|
|
The `color' argument is the background color for the balloon. It
|
|
defaults to `balloon-color'.
|
|
|
|
The result is a balloon, not a pict. The `balloon-pict' function
|
|
extracts a pict whose bounding box does not include the spike, but
|
|
includes the rest of the image. (The `balloon-point-x' and
|
|
`balloon-point-y' functions specify the location of the spike point.)
|
|
|
|
> (pip-wrap-balloon pict spike-sym dx dy [color corner-radius])
|
|
|
|
Like `wrap-balloon', but produces a zero-sized pict suitable for use
|
|
with `pin-over'.
|
|
|
|
> (pin-balloon balloon pict to-pict find-to-pos)
|
|
> (pin-balloon balloon pict x y)
|
|
|
|
Superimposes the pict in `balloon' onto `pict' to produce a new
|
|
pict. The balloon is positioned so that its spike points to the
|
|
location specified by either `x' and `y' (numbers) or `to-pict' and
|
|
`find-to-pos'. In the latter case, `to-pict' is a sub-pict in `pict'
|
|
and `find-to-pos' is a function like `lt-find'.
|
|
|
|
The resulting pict has the same bounding box, descent, and ascent as
|
|
`pict', even if the balloon extends beyond the bounding box.
|
|
|
|
> (place-balloon balloon pict to-pict find-to-pos)
|
|
> (place-balloon balloon pict x y)
|
|
|
|
Obsolete version of `pin-balloon' where `find-to-pos' is a function
|
|
like `find-lt' (i.e., the y result is flipped).
|
|
|
|
> (balloon w h corner-radius spike-pos dx dy color)
|
|
|
|
Creates a balloon, much like `wrap-balloon' except that the balloon's
|
|
width is `w' and its height is `h'. The `corner-radius' argument
|
|
specifies the radius for the balloon's rounded corners; if the radius
|
|
is positive, the value is used as the radius of the rounded corner,
|
|
but if radius is negative, the absolute value is used as the
|
|
proportion of the smallest dimension of the balloon.
|
|
|
|
> (make-balloon pict num num) -> balloon
|
|
> (balloon-pict balloon) -> pict
|
|
> (balloon-point-x balloon) -> num
|
|
> (balloon-point-y balloon) -> num
|
|
> (balloon? v) -> bool
|
|
|
|
A balloon value encapsulates a pict and the position of the balloon's
|
|
spike relative to the balloon's top-left corner.
|
|
|
|
> balloon-color
|
|
|
|
The default background color for a balloon.
|
|
|
|
------------------------------------------------------------
|
|
_face.ss_
|
|
------------------------------------------------------------
|
|
|
|
The "face.ss" module provides functions for a kind of
|
|
Mr.-Potatohead-style face library. The _face-demo.ss_ module
|
|
implements an interactive browser for face configurations.
|
|
|
|
> default-face-color - orange
|
|
|
|
> (face mood-symbol [color]) - returns a pict a pre-configured face
|
|
with the given base color. The built-in configurations, selected by
|
|
mood-symbol, are as follows:
|
|
|
|
'unhappy - (face* 'none 'plain #t default-face-color 6)
|
|
'sortof-unhappy - (face* 'worried 'grimace #t default-face-color 6)
|
|
'sortof-happy - (face* 'worried 'medium #f default-face-color 6)
|
|
'happy - (face* 'none 'plain #f default-face-color 6)
|
|
'happier - (face* 'none 'large #f default-face-color 3)
|
|
'embarrassed - (face* 'worried 'medium #f default-face-color 3)
|
|
'badly-embarrassed - (face* 'worried 'medium #t default-face-color 3)
|
|
'unhappier - (face* 'normal 'large #t default-face-color 3)
|
|
'happiest - (face* 'normal 'huge #f default-face-color 0 -3)
|
|
'unhappiest - (face* 'normal 'huge #t default-face-color 0 -3)
|
|
'mad - (face* 'angry 'grimace #t default-face-color 0)
|
|
'mean - (face* 'angry 'narrow #f default-face-color 0)
|
|
'surprised - (face* 'worried 'oh #t default-face-color -4 -3 2)
|
|
|
|
> (face* eyebrow-kind mouth-kind frown? [color eye-inset eyebrow-dy pupil-dx pupil-dy])
|
|
- returns a pict for a configured face:
|
|
|
|
- eyebrow-kind is one of 'none, 'normal, 'worried, or 'angry
|
|
- mouth-kind is one of 'plain, 'narrow, 'medium, 'large, 'huge,
|
|
'grimace, 'oh, or 'tongue
|
|
- frown? determines whether the mouth is up or down
|
|
- color is either a color string or a color% object
|
|
- eye-inset adjusts the eye size; recommend values: between 0 and 10
|
|
- eyebrow-dy adjusts the eyebrows; recommend values: between -5 and 5
|
|
- pupil-dx adjusts the pupil; recommend values: between -10 and 10
|
|
- pupil-dy adjusts the pupil; recommend values: between -15 and 15
|
|
|
|
In addition to the above, the function also accepts these keywords,
|
|
each of which is a boolean. With the exception of the last one, they
|
|
control if there is a shading on a particular feature in the face
|
|
(shading tends to look worse than just anti-aliasing when the face is
|
|
small). The last one controls the visibility of the teeth.
|
|
|
|
#:eyebrow-shading?
|
|
#:mouth-shading?
|
|
#:eye-shading?
|
|
#:tongue-shading?
|
|
#:face-background-shading?
|
|
#:teeth?
|
|
|
|
------------------------------------------------------------
|
|
_flash.ss_
|
|
------------------------------------------------------------
|
|
|
|
> (filled-flash width height [points spike-fraction rotation])
|
|
- returns a pict for a "flash" (a spiky oval, like the
|
|
yellow background that goes behind a "New!" logo).
|
|
|
|
The `height' and `width' arguments determine the size of the oval
|
|
in which the flash is drawn, prior to rotation. The actual height
|
|
and width may be smaller if `points' is not a multiple of 4, and
|
|
the actuall height and width will be different if the flash is
|
|
rotated.
|
|
|
|
The `points' argument defaults to 10, and it determines
|
|
the number of points on the flash.
|
|
|
|
The `spike-fraction' argument determines how big the flash spikes
|
|
are compared to the bounding oval. It should be a value between 0
|
|
and 1 (exclusive), and the default is 0.25.
|
|
|
|
The `rotation' argument specifies an angle in radians for
|
|
counter-clockwise rotation.
|
|
|
|
The flash is drawn in the default color.
|
|
|
|
> (outline-flash width height [points spike-fraction rotation])
|
|
- like `filled-flash', but drawing only the outline.
|
|
|
|
------------------------------------------------------------
|
|
_code.ss_
|
|
------------------------------------------------------------
|
|
|
|
The "code.ss" module provides a unit for typesetting Scheme code a la
|
|
SlaTeX.
|
|
|
|
The _code@_ unit imports _code-params^_ and exports _code^_. The
|
|
_code-params^_ signature contains two elements:
|
|
|
|
current-font-size - a thunk to obtain the font size to use for
|
|
text
|
|
line-sep - an integer for the amount of space (in drawing units) to
|
|
insert between lines of text
|
|
|
|
The _code^_ unit supplies the following
|
|
|
|
> (typeset-code stx) - produces a pict for code in the given
|
|
syntax object. The source-location information of the
|
|
syntax object determines the line breaks, line indenting,
|
|
and space within a row. Empty rows are ignored. (Beware
|
|
that if you use read-syntax on a file port, you may have
|
|
to turn on line counting via port-count-lines! for the
|
|
code to typeset properly.)
|
|
|
|
Normally, `typeset-code' is used through a macro (often called
|
|
`code') that is generated by `define-code'. See below for more
|
|
information.
|
|
|
|
Embedded picts within `stx' are used directly. Row elements are
|
|
combined using `htl-append', so use `code-align' (see below) as
|
|
necessary to add an ascent to ascentless picts.
|
|
|
|
The resulting pict is actually an instance of code-pict, which is a
|
|
sub-type of `pict'. When an embedded pict in `stx' is a code-pict,
|
|
then elements (such as closing parens) are added after the code-pict
|
|
based on the code-pict's bottom line, instead of the code-pict's
|
|
bounding box. See also `code-pict-bottom-line-pict' and
|
|
`pict->code-pict'.
|
|
|
|
An identifier that starts with an underscore is italicized in the
|
|
pict and the underscore is dropped, unless the
|
|
`code-italic-underscore-enabled' parameter is set to false. Also,
|
|
unless `code-scripts-enabled' is set to false, underscores and
|
|
carets in the middle of a word create superscripts and subscripts
|
|
(like TeX); for example `foo^4_ok' is displayed as the identifier
|
|
"foo" with a "4" superscript and an "ok" subscript.
|
|
|
|
Further, uses of certain keywords in `stx' typeset specially:
|
|
|
|
> code:blank - produces a space
|
|
> (code:comment s ...) - produces a comment block, with each `s'
|
|
on its own line; each `s' must be a string
|
|
or a pict
|
|
> (code:line datum ...) - typesets the `datum' sequence, mostly useful
|
|
for the top-level sequence, since
|
|
`typeset-code' takes only one argument
|
|
> (code:contract datum ...) - like code:line, but every `datum' is
|
|
colored as a comment, and a semi-colon
|
|
is prefixed to every line
|
|
> (code:template datum ...) - like code:line, but a semi-colon
|
|
is prefixed to every line
|
|
> $ - typesets as a vertical bar (for no
|
|
particularly good reason)
|
|
|
|
> current-code-font - parameter for a base font used to typeset text.
|
|
The default is `(bold . modern).
|
|
> current-code-tt - parameter for a one-argument procedure to turn a
|
|
string into a pict, used to typeset text. The default is
|
|
(lambda (s) (text s (current-code-font) (current-font-size)))
|
|
This procedure is not used to typeset subscripts or other items
|
|
that require font changes, but `current-code-font' is always used.
|
|
|
|
> current-comment-color - parameter for a string or color% for comments
|
|
> current-keyword-color - parameter for a string or color% for keywords
|
|
> current-id-color - parameter for a string or color% for identifiers
|
|
> current-literal-color - parameter for a string or color% for literals
|
|
> current-const-color - parameter for a string or color% for constants
|
|
> current-base-color - parameter for a string or color% for everything else
|
|
|
|
> current-reader-forms - parameter for a list of symbols indicating
|
|
which built-in reader forms should be used; the default is '(quote
|
|
quasiquote unquote unquote-splicing syntax quasisyntax unsyntax
|
|
unsyntax-splicing); remove a symbol to suppress the corresponding
|
|
reader output
|
|
|
|
The following four are for backward compatibility:
|
|
> comment-color - default string/color% for comments
|
|
> keyword-color - default string/color% for keywords
|
|
> id-color - default string/color% for ids
|
|
> literal-color - default string/color% for literals
|
|
|
|
> (code-align pict) - adjusts the ascent of `pict' so that its bottom
|
|
aligns with the baseline for text; use this function when `pict'
|
|
has no ascent.
|
|
|
|
> current-keyword-list - a parameter, a list of strings to color as
|
|
keywords; the default includes the Racket syntactic form names
|
|
> current-const-list - a parameter, a list of strings to color as
|
|
constants; the default is empty
|
|
> current-literal-list - a parameter, a list of strings to color as
|
|
literals; the default is empty
|
|
|
|
> mzscheme-const-list - a list of strings that could be used to initialize
|
|
the `current-const-list' parameter
|
|
|
|
> code-colorize-enabled - a parameter to enable or disable all code
|
|
coloring; the default is #t
|
|
|
|
> code-colorize-quote-enabled - a parameter to control whether everything
|
|
under a quote is colorized as a literal (like DrRacket's Check Syntax,
|
|
and unlike DrRacket's interactive text coloring); the default is #t
|
|
|
|
> code-italic-underscore-enabled - a boolean parameter to control
|
|
whether underscore-prefixed identifiers are italicized (dropping
|
|
the underscore); the default is #t
|
|
|
|
> code-scripts-enabled - a boolean parameter to control whether
|
|
TeX-style subscripts and subscripts are recognized in an identifier
|
|
|
|
> (code-pict-bottom-line-pict pict) - returns a pict inside of the
|
|
given code-pict that represents the end of the code-pict's bottom
|
|
line; if `pict' is a pict but not a code-pict, the result is #f
|
|
|
|
> (pict->code-pict pict bl-pict-or-false) - returns a code-pict if
|
|
`bl-pict-of-false' is not false; the code-pict is like the given
|
|
`pict', except that it reports `bl-pict-or-false' as its bottom-line
|
|
pict (for adding closing parens after, etc.)
|
|
|
|
|
|
In addition to the `code@' unit, the "code.ss" module exports a
|
|
`define-code' macro for defining other macros:
|
|
|
|
> (define-code code-id typeset-code-id)
|
|
> (define-code code-id typeset-code-id escape-id)
|
|
|
|
Defines `code-id' as a macro that uses `typeset-code-id', which is a
|
|
function with the same input as `typeset-code'. The `escape-id' form
|
|
defaults to `unsyntax'.
|
|
|
|
The `code-id' syntactic form takes a sequence of `datum's:
|
|
|
|
(code datum ...)
|
|
|
|
It produces a pict that typesets the sequence. Source-location
|
|
information for the `datum' determine the layout of code in the
|
|
resulting pict. A pict datum is drawn as itself.
|
|
|
|
If a `datum' contains `(escape-id expr)' (perhaps as #,expr when
|
|
`escape-id' is `unsyntax'), then the `expr' is evaluated and the
|
|
result datum is spliced in place of the `unsyntax' form in
|
|
`datum'. If the result is not a syntax object, it is given the
|
|
source location of the `(unsyntax expr)'.
|
|
|
|
The `code' syntactic form expands to a use of `typeset-code'. The
|
|
`datum's are not merely syntax-quoted, because then the compiled
|
|
form of the call would loose source information. Instead, `code'
|
|
expands to an expression that preserves expansion-time
|
|
source-location information.
|