suzanne.soy/gui
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

misc racket renamings

Browse Source 
original commit: c023c460bce4996af6038a78aed2b0103252404b
This commit is contained in:
Matthew Flatt 2010-05-07 11:01:59 -06:00
parent fcc39cd008
commit 36405c90a5
2 changed files with 116 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
collects/framework/private/scheme.rkt
View File

@ -323,7 +323,7 @@
(define (add-coloring-preferences-panel) (define (add-coloring-preferences-panel)
(color-prefs:add-to-preferences-panel (color-prefs:add-to-preferences-panel
"Scheme" "Racket"
(λ (parent) (λ (parent)
(for-each (for-each
(λ (line) (λ (line)
@ -1187,7 +1187,7 @@
(define/override (put-file text sup directory default-name) (define/override (put-file text sup directory default-name)
(parameterize ([finder:default-extension "ss"] (parameterize ([finder:default-extension "ss"]
[finder:default-filters '(["Scheme Sources" "*.ss;*.scm"] [finder:default-filters '(["Racket Sources" "*.rkt;*.ss;*.scm"]
["Any" "*.*"])]) ["Any" "*.*"])])
;; don't call the surrogate's super, since it sets the default extension ;; don't call the surrogate's super, since it sets the default extension
(sup directory default-name))) (sup directory default-name)))

228
collects/scribblings/gui/wxme.scrbl
View File

@ -19,17 +19,17 @@
@title{WXME Decoding} @title{WXME Decoding}
@defmodule[wxme]{The @schememodname[wxme] library provides tools for @defmodule[wxme]{The @racketmodname[wxme] library provides tools for
reading @tech{WXME} @scheme[editor<%>]-format files (see reading @tech{WXME} @racket[editor<%>]-format files (see
@secref["editorfileformat"]) without the @scheme[scheme/gui] library @secref["editorfileformat"]) without the @racket[racket/gui] library
(i.e., using @exec{mzscheme} instead of @exec{mred}).} (i.e., using @exec{racket} instead of @exec{gracket}).}
@defproc[(is-wxme-stream? [in input-port?]) boolean?]{ @defproc[(is-wxme-stream? [in input-port?]) boolean?]{
Peeks from @scheme[in] and returns @scheme[#t] if it starts with the Peeks from @racket[in] and returns @racket[#t] if it starts with the
magic bytes indicating a @tech{WXME}-format stream (see magic bytes indicating a @tech{WXME}-format stream (see
@secref["editorfileformat"]), @scheme[#f] otherwise.} @secref["editorfileformat"]), @racket[#f] otherwise.}
@defproc[(wxme-port->text-port [in input-port?] [close? any/c #t]) @defproc[(wxme-port->text-port [in input-port?] [close? any/c #t])
@ -37,10 +37,10 @@ magic bytes indicating a @tech{WXME}-format stream (see
Takes an input port whose stream starts with @tech{WXME}-format data Takes an input port whose stream starts with @tech{WXME}-format data
and returns an input port that produces a text form of the WXME and returns an input port that produces a text form of the WXME
content, like the result of opening a WXME file in DrScheme and saving content, like the result of opening a WXME file in DrRacket and saving
it as text. it as text.
If @scheme[close?] is true, then closing the result port close the If @racket[close?] is true, then closing the result port close the
original port. original port.
See @secref["snipclassmapping"] for information about the kinds of See @secref["snipclassmapping"] for information about the kinds of
@ -55,24 +55,24 @@ non-text content that can be read.}
Takes an input port whose stream starts with @tech{WXME}-format data Takes an input port whose stream starts with @tech{WXME}-format data
and returns an input port that produces text content converted to and returns an input port that produces text content converted to
bytes, and non-text content as ``special'' values (see bytes, and non-text content as ``special'' values (see
@scheme[read-char-or-special]). @racket[read-char-or-special]).
These special values produced by the new input port are different than These special values produced by the new input port are different than
the ones produced by reading a file into an @scheme[editor<%>] the ones produced by reading a file into an @racket[editor<%>]
object. Instead of instances of the @scheme[snip%], the special values object. Instead of instances of the @racket[snip%], the special values
are typically simple extensions of @scheme[object%]. See are typically simple extensions of @racket[object%]. See
@secref["snipclassmapping"] for information about the kinds of @secref["snipclassmapping"] for information about the kinds of
non-text content that can be read. non-text content that can be read.
If @scheme[close?] is true, then closing the result port close the If @racket[close?] is true, then closing the result port close the
original port. original port.
The @scheme[snip-filter] procedure is applied to any special value The @racket[snip-filter] procedure is applied to any special value
generated for the stream, and its result is used as an alternate generated for the stream, and its result is used as an alternate
special value. special value.
If a special value (possibly produced by the filter procedure) is an If a special value (possibly produced by the filter procedure) is an
object implementing the @scheme[readable<%>] interface, then the object implementing the @racket[readable<%>] interface, then the
object's @method[readable<%> read-special] method is called to produce object's @method[readable<%> read-special] method is called to produce
the special value.} the special value.}
@ -93,8 +93,8 @@ any) is consumed.}
void?]{ void?]{
Maps a snip-class name to a quoted module path that provides a Maps a snip-class name to a quoted module path that provides a
@scheme[reader%] implementation. The module path must have the form @racket[reader%] implementation. The module path must have the form
@scheme['(lib #,(scheme _string ...))], where each @scheme[_string] @racket['(lib #,(racket _string ...))], where each @racket[_string]
contains only alpha-numeric ASCII characters, @litchar{.}, contains only alpha-numeric ASCII characters, @litchar{.},
@litchar{_}, @litchar{-}, and spaces.} @litchar{_}, @litchar{-}, and spaces.}
@ -102,14 +102,14 @@ contains only alpha-numeric ASCII characters, @litchar{.},
@defproc[(string->lib-path [str string?] [gui? any/c]) @defproc[(string->lib-path [str string?] [gui? any/c])
(cons/c (one-of/c 'lib) (listof string?))]{ (cons/c (one-of/c 'lib) (listof string?))]{
Returns a quoted module path for @scheme[str] for either Returns a quoted module path for @racket[str] for either
@scheme[editor<%>] mode when @scheme[gui?] is true, or @racket[editor<%>] mode when @racket[gui?] is true, or
@schememodname[wxme] mode when @scheme[gui?] is @scheme[#f]. For the @racketmodname[wxme] mode when @racket[gui?] is @racket[#f]. For the
latter, built-in mappings and mapping registered via latter, built-in mappings and mapping registered via
@scheme[register-lib-mapping!] are used. If @scheme[str] cannot be @racket[register-lib-mapping!] are used. If @racket[str] cannot be
parsed as a library path, and if no mapping is available (either parsed as a library path, and if no mapping is available (either
because the class is built-in or not known), the result is because the class is built-in or not known), the result is
@scheme[#f].} @racket[#f].}
@defboolparam[unknown-extensions-skip-enabled skip?]{ @defboolparam[unknown-extensions-skip-enabled skip?]{
@ -130,26 +130,26 @@ default is the current platform's endian order.}
@defproc[(wxme-read [in input-port?]) any/c]{ @defproc[(wxme-read [in input-port?]) any/c]{
Like @scheme[read], but for a stream that starts with Like @racket[read], but for a stream that starts with
@tech{WXME}-format data. If multiple S-expressions are in the @tech{WXME}-format data. If multiple S-expressions are in the
@tech{WXME} data, they are all read and combined with @tech{WXME} data, they are all read and combined with
@scheme['begin]. @racket['begin].
If @scheme[scheme/gui/base] is available (as determined by If @racket[racket/gui/base] is available (as determined by
@scheme[gui-available?]), then @scheme[open-input-text-editor] is @racket[gui-available?]), then @racket[open-input-text-editor] is
used. Otherwise, @scheme[wxme-port->port] is used.} used. Otherwise, @racket[wxme-port->port] is used.}
@defproc[(wxme-read-syntax [source-v any/c] [in input-port?]) @defproc[(wxme-read-syntax [source-v any/c] [in input-port?])
(or/c syntax? eof-object?)]{ (or/c syntax? eof-object?)]{
Like @scheme[read-syntax], but for a @tech{WXME}-format input stream. Like @racket[read-syntax], but for a @tech{WXME}-format input stream.
If multiple S-expressions are in the @tech{WXME} data, they are all If multiple S-expressions are in the @tech{WXME} data, they are all
read and combined with @scheme['begin]. read and combined with @racket['begin].
If @scheme[scheme/gui/base] is available (as determined by If @racket[racket/gui/base] is available (as determined by
@scheme[gui-available?]), then @scheme[open-input-text-editor] is @racket[gui-available?]), then @racket[open-input-text-editor] is
used. Otherwise, @scheme[wxme-port->port] is used.} used. Otherwise, @racket[wxme-port->port] is used.}
@definterface[snip-reader<%> ()]{ @definterface[snip-reader<%> ()]{
@ -175,7 +175,7 @@ stream. This method reads the data and returns either bytes to be
returned as part of the decoded stream or any other kind of value to returned as part of the decoded stream or any other kind of value to
be returned as a ``special'' value from the decoded stream. The result be returned as a ``special'' value from the decoded stream. The result
value can optionally be an object that implements value can optionally be an object that implements
@scheme[readable<%>].} @racket[readable<%>].}
} }
@ -200,14 +200,14 @@ obtain the ``special'' result from the @tech{WXME}-decoding port.}
@definterface[stream<%> ()]{ @definterface[stream<%> ()]{
Represents a @tech{WXME} input stream for use by Represents a @tech{WXME} input stream for use by
@scheme[snip-reader<%>] instances. @racket[snip-reader<%>] instances.
@defmethod[(read-integer [what any/c]) exact-integer?]{ @defmethod[(read-integer [what any/c]) exact-integer?]{
Reads an exact integer, analogous to @method[editor-stream-in% Reads an exact integer, analogous to @method[editor-stream-in%
get-exact]. get-exact].
The @scheme[what] field describes what is being read, for The @racket[what] field describes what is being read, for
error-message purposes, in case the stream does not continue with an error-message purposes, in case the stream does not continue with an
integer.} integer.}
@ -216,34 +216,34 @@ integer.}
Reads an exact integer that has a fixed size in the stream, analogous Reads an exact integer that has a fixed size in the stream, analogous
to @method[editor-stream-in% get-fixed]. to @method[editor-stream-in% get-fixed].
The @scheme[what] argument is as for @method[stream<%> read-integer].} The @racket[what] argument is as for @method[stream<%> read-integer].}
@defmethod[(read-inexact [what any/c]) (and/c real? inexact?)]{ @defmethod[(read-inexact [what any/c]) (and/c real? inexact?)]{
Reads an inexact real number, analogous to @method[editor-stream-in% Reads an inexact real number, analogous to @method[editor-stream-in%
get-inexact]. get-inexact].
The @scheme[what] argument is as for @method[stream<%> read-integer].} The @racket[what] argument is as for @method[stream<%> read-integer].}
@defmethod[(read-raw-bytes [what any/c]) bytes?]{ @defmethod[(read-raw-bytes [what any/c]) bytes?]{
Reads raw bytes, analogous to @method[editor-stream-in% Reads raw bytes, analogous to @method[editor-stream-in%
get-unterminated-bytes]. get-unterminated-bytes].
The @scheme[what] argument is as for @method[stream<%> read-integer].} The @racket[what] argument is as for @method[stream<%> read-integer].}
@defmethod[(read-bytes [what any/c]) bytes?]{ @defmethod[(read-bytes [what any/c]) bytes?]{
Reads raw bytes, analogous to @method[editor-stream-in% get-bytes]. Reads raw bytes, analogous to @method[editor-stream-in% get-bytes].
The @scheme[what] argument is as for @method[stream<%> read-integer].} The @racket[what] argument is as for @method[stream<%> read-integer].}
@defmethod[(read-editor [what any/c]) input-port?]{ @defmethod[(read-editor [what any/c]) input-port?]{
Reads a nested editor, producing a new input port to extract the Reads a nested editor, producing a new input port to extract the
editor's content. editor's content.
The @scheme[what] argument is as for @method[stream<%> read-integer].} The @racket[what] argument is as for @method[stream<%> read-integer].}
} }
@; ---------------------------------------------------------------------- @; ----------------------------------------------------------------------
@ -256,77 +256,77 @@ time. See also @secref["editorsnipclasses"].
Ideally, the snip-class name is generated as Ideally, the snip-class name is generated as
@schemeblock[ @racketblock[
(format "~s" (list '(lib #,(scheme _string ...)) (format "~s" (list '(lib #,(racket _string ...))
'(lib #,(scheme _string ...)))) '(lib #,(racket _string ...))))
] ]
where each element of the @scheme[format]ed list is a quoted module where each element of the @racket[format]ed list is a quoted module
path (see @scheme[module-path?]). The @scheme[_string]s must contain only path (see @racket[module-path?]). The @racket[_string]s must contain only
alpha-numeric ASCII characters, plus @litchar{.}, @litchar{_}, alpha-numeric ASCII characters, plus @litchar{.}, @litchar{_},
@litchar{-}, and spaces, and they must not be @scheme["."] or @litchar{-}, and spaces, and they must not be @racket["."] or
@scheme[".."]. @racket[".."].
In that case, the first quoted module path is used for loading In that case, the first quoted module path is used for loading
@tech{WXME} files in graphical mode; the corresponding module must @tech{WXME} files in graphical mode; the corresponding module must
provide @schemeidfont{snip-class} object that implements the provide @racketidfont{snip-class} object that implements the
@scheme[snip-class%] class. The second quoted module path is used by @racket[snip-class%] class. The second quoted module path is used by
the @schememodname[wxme] library for converting @tech{WXME} streams the @racketmodname[wxme] library for converting @tech{WXME} streams
without graphical support; the corresponding module must provide a without graphical support; the corresponding module must provide a
@schemeidfont{reader} object that implements the @scheme[reader<%>] @racketidfont{reader} object that implements the @racket[reader<%>]
interface. Naturally, the @scheme[snip-class%] instance and interface. Naturally, the @racket[snip-class%] instance and
@scheme[reader<%>] instance are expected to parse the same format, but @racket[reader<%>] instance are expected to parse the same format, but
generate different results suitable for the different contexts (i.e., generate different results suitable for the different contexts (i.e.,
graphical or not). graphical or not).
If a snip-class name is generated as If a snip-class name is generated as
@schemeblock[ @racketblock[
(format "~s" '(lib #,(scheme _string ...))) (format "~s" '(lib #,(racket _string ...)))
] ]
then graphical mode uses the sole module path, and then graphical mode uses the sole module path, and
@schememodname[wxme] needs a compatibility mapping. Install one with @racketmodname[wxme] needs a compatibility mapping. Install one with
@scheme[register-lib-mapping!]. @racket[register-lib-mapping!].
If a snip-class name has neither of the above formats, then graphical If a snip-class name has neither of the above formats, then graphical
mode can use the data only if a snip class is registered for the name, mode can use the data only if a snip class is registered for the name,
or if it the name of one of the built-in classes: @scheme["wxtext"], or if it the name of one of the built-in classes: @racket["wxtext"],
@scheme["wxtab"], @scheme["wximage"], or @scheme["wxmedia"] (for @racket["wxtab"], @racket["wximage"], or @racket["wxmedia"] (for
nested editors). The @schememodname[wxme] library needs a nested editors). The @racketmodname[wxme] library needs a
compatibility mapping installed with @scheme[register-lib-mapping!] compatibility mapping installed with @racket[register-lib-mapping!]
if it is not one of the built-in classes. if it is not one of the built-in classes.
Several compatibility mappings are installed automatically for the Several compatibility mappings are installed automatically for the
@schememodname[wxme] library. They correspond to popular graphical @racketmodname[wxme] library. They correspond to popular graphical
elements supported by various versions of DrScheme, including comment elements supported by various versions of DrRacket, including comment
boxes, fractions, XML boxes, Scheme boxes, text boxes, and images boxes, fractions, XML boxes, Racket boxes, text boxes, and images
generated by the ``world'' and ``image'' teachpacks (or, more generated by the ``world'' and ``image'' teachpacks (or, more
generally, from @schememodname[mrlib/cache-image-snip]), and test-case generally, from @racketmodname[mrlib/cache-image-snip]), and test-case
boxes. boxes.
For a port created by @scheme[wxme-port->port], nested editors are For a port created by @racket[wxme-port->port], nested editors are
represented by instances of the @scheme[editor%] class provided by the represented by instances of the @racket[editor%] class provided by the
@schememodname[wxme/editor] library. This class provides a single @racketmodname[wxme/editor] library. This class provides a single
method, @method[editor% get-content-port], which returns a port for method, @method[editor% get-content-port], which returns a port for
the editor's content. Images are represented as instances of the the editor's content. Images are represented as instances of the
@scheme[image%] class provided by the @schememodname[wxme/image] @racket[image%] class provided by the @racketmodname[wxme/image]
library. library.
Comment boxes are represented as instances of a class that extends Comment boxes are represented as instances of a class that extends
@scheme[editor%] to implement @scheme[readable<%>]; see @racket[editor%] to implement @racket[readable<%>]; see
@schememodname[wxme/comment]. The read form produces a special comment @racketmodname[wxme/comment]. The read form produces a special comment
(created by @scheme[make-special-comment]), so that the comment box (created by @racket[make-special-comment]), so that the comment box
disappears when @scheme[read] is used to read the stream; the disappears when @racket[read] is used to read the stream; the
special-comment content is the readable instance. XML, Scheme, and special-comment content is the readable instance. XML, Racket, and
text boxes similarly produce instances of @scheme[editor%] and text boxes similarly produce instances of @racket[editor%] and
@scheme[readable<%>] that expand in the usual way; see @racket[readable<%>] that expand in the usual way; see
@schememodname[wxme/xml], @schememodname[wxme/scheme], and @racketmodname[wxme/xml], @racketmodname[wxme/scheme], and
@scheme[wxme/text]. Images from the ``world'' and ``image'' teachpacks @racket[wxme/text]. Images from the ``world'' and ``image'' teachpacks
are packaged as instances of @scheme[cache-image%] from the are packaged as instances of @racket[cache-image%] from the
@schememodname[wxme/cache-image] library. Test-case boxes are packaged @racketmodname[wxme/cache-image] library. Test-case boxes are packaged
as instances of @scheme[test-case%] from the as instances of @racket[test-case%] from the
@schememodname[wxme/test-case] library. @racketmodname[wxme/test-case] library.
@; ---------------------------------------- @; ----------------------------------------
@ -341,7 +341,7 @@ mode.
@defmethod[(get-content-port) input-port?]{ @defmethod[(get-content-port) input-port?]{
Returns a port (like the one from @scheme[wxme-port->port]) for the Returns a port (like the one from @racket[wxme-port->port]) for the
editor's content.} editor's content.}
} }
@ -358,7 +358,7 @@ Instantiated for images in a @tech{WXME} stream in text mode.
@defmethod[(get-filename) (or/c bytes? false/c)]{ @defmethod[(get-filename) (or/c bytes? false/c)]{
Returns a filename as bytes, or @scheme[#f] if data is available Returns a filename as bytes, or @racket[#f] if data is available
instead.} instead.}
@defmethod[(get-data) (or/c bytes? false/c)]{ @defmethod[(get-data) (or/c bytes? false/c)]{
@ -391,7 +391,7 @@ display image.}
@; ---------------------------------------- @; ----------------------------------------
@section{DrScheme Comment Boxes} @section{DrRacket Comment Boxes}
@defmodule[wxme/comment] @defmodule[wxme/comment]
@ -403,7 +403,7 @@ A text-mode reader for comment boxes.}]
@defclass[comment-editor% editor% (readable<%>)]{ @defclass[comment-editor% editor% (readable<%>)]{
Instantiated for DrScheme comment boxes in a @tech{WXME} stream for Instantiated for DrRacket comment boxes in a @tech{WXME} stream for
text mode. text mode.
@defmethod[(get-data) false/c]{ @defmethod[(get-data) false/c]{
@ -418,14 +418,14 @@ No data is available.
[position (or/c exact-nonnegative-integer? false/c)]) [position (or/c exact-nonnegative-integer? false/c)])
any/c]{ any/c]{
Generates a special comment using @scheme[make-special-comment]. The Generates a special comment using @racket[make-special-comment]. The
special comment contains the comment text.} special comment contains the comment text.}
} }
@; ---------------------------------------- @; ----------------------------------------
@section{DrScheme XML Boxes} @section{DrRacket XML Boxes}
@defmodule[wxme/xml] @defmodule[wxme/xml]
@ -437,13 +437,13 @@ A text-mode reader for XML boxes.}]
@defclass[xml-editor% editor% (readable<%>)]{ @defclass[xml-editor% editor% (readable<%>)]{
Instantiated for DrScheme XML boxes in a @tech{WXME} stream for text Instantiated for DrRacket XML boxes in a @tech{WXME} stream for text
mode. mode.
@defmethod[(get-data) any/c]{ @defmethod[(get-data) any/c]{
Returns @scheme[#t] if whitespace is elimited from the contained XML Returns @racket[#t] if whitespace is elimited from the contained XML
literal, @scheme[#f] otherwise.} literal, @racket[#f] otherwise.}
@defmethod[(read-special [source any/c] @defmethod[(read-special [source any/c]
[line (or/c exact-nonnegative-integer? false/c)] [line (or/c exact-nonnegative-integer? false/c)]
@ -451,33 +451,33 @@ literal, @scheme[#f] otherwise.}
[position (or/c exact-nonnegative-integer? false/c)]) [position (or/c exact-nonnegative-integer? false/c)])
any/c]{ any/c]{
Generates a @scheme[quasiquote] S-expression that enclosed the XML, Generates a @racket[quasiquote] S-expression that enclosed the XML,
with @scheme[unquote] and @scheme[unquote-splicing] escapes for nested with @racket[unquote] and @racket[unquote-splicing] escapes for nested
Scheme boxes.} Racket boxes.}
} }
@; ---------------------------------------- @; ----------------------------------------
@section{DrScheme Scheme Boxes} @section{DrRacket Racket Boxes}
@defmodule[wxme/scheme] @defmodule[wxme/scheme]
@in[wxme/scheme @in[wxme/scheme
@defthing[reader (is-a?/c snip-reader<%>)]{ @defthing[reader (is-a?/c snip-reader<%>)]{
A text-mode reader for Scheme boxes.}] A text-mode reader for Racket boxes.}]
@defclass[scheme-editor% editor% (readable<%>)]{ @defclass[racket-editor% editor% (readable<%>)]{
Instantiated for DrScheme Scheme boxes in a @tech{WXME} stream for text Instantiated for DrRacket Racket boxes in a @tech{WXME} stream for text
mode. mode.
@defmethod[(get-data) any/c]{ @defmethod[(get-data) any/c]{
Returns @scheme[#t] if the box corresponds to a splicing unquote, Returns @racket[#t] if the box corresponds to a splicing unquote,
@scheme[#f] for a non-splicing unquote.} @racket[#f] for a non-splicing unquote.}
@defmethod[(read-special [source any/c] @defmethod[(read-special [source any/c]
[line (or/c exact-nonnegative-integer? false/c)] [line (or/c exact-nonnegative-integer? false/c)]
@ -491,7 +491,7 @@ Generates an S-expression for the code in the box.}
@; ---------------------------------------- @; ----------------------------------------
@section{DrScheme Text Boxes} @section{DrRacket Text Boxes}
@defmodule[wxme/text] @defmodule[wxme/text]
@ -503,7 +503,7 @@ A text-mode reader for text boxes.}]
@defclass[text-editor% editor% (readable<%>)]{ @defclass[text-editor% editor% (readable<%>)]{
Instantiated for DrScheme text boxes in a @tech{WXME} stream for text Instantiated for DrRacket text boxes in a @tech{WXME} stream for text
mode. mode.
@defmethod[(get-data) false/c]{ @defmethod[(get-data) false/c]{
@ -522,19 +522,19 @@ Generates a string containing the text.}
@; ---------------------------------------- @; ----------------------------------------
@section{DrScheme Fractions} @section{DrRacket Fractions}
@defmodule[wxme/number] @defmodule[wxme/number]
@in[wxme/number @in[wxme/number
@defthing[reader (is-a?/c snip-reader<%>)]{ @defthing[reader (is-a?/c snip-reader<%>)]{
A text-mode reader for DrScheme fractions that generates exact, A text-mode reader for DrRacket fractions that generates exact,
rational numbers.}] rational numbers.}]
@; ---------------------------------------- @; ----------------------------------------
@section{DrScheme Teachpack Images} @section{DrRacket Teachpack Images}
@defmodule[wxme/cache-image] @defmodule[wxme/cache-image]
@ -543,12 +543,12 @@ rational numbers.}]
A text-mode reader for images in a WXME stream generated by the A text-mode reader for images in a WXME stream generated by the
``image'' and ``world'' teachpacks---or, more generally, by ``image'' and ``world'' teachpacks---or, more generally, by
@schememodname[mrlib/cache-image-snip].}] @racketmodname[mrlib/cache-image-snip].}]
@defclass[cache-image% object% ()]{ @defclass[cache-image% object% ()]{
Instantiated for DrScheme teachpack boxes in a @tech{WXME} stream for Instantiated for DrRacket teachpack boxes in a @tech{WXME} stream for
text mode. text mode.
@defmethod[(get-argb) (vectorof byte?)]{ @defmethod[(get-argb) (vectorof byte?)]{
@ -573,19 +573,19 @@ Returns an offset down into the image for the pinhole.}
} }
@section{DrScheme Test-Case Boxes} @section{DrRacket Test-Case Boxes}
@defmodule[wxme/test-case] @defmodule[wxme/test-case]
@in[wxme/test-case @in[wxme/test-case
@defthing[reader (is-a?/c snip-reader<%>)]{ @defthing[reader (is-a?/c snip-reader<%>)]{
A text-mode reader for DrScheme test-case boxes in a WXME stream. It A text-mode reader for DrRacket test-case boxes in a WXME stream. It
generates instances of @scheme[test-case%].}] generates instances of @racket[test-case%].}]
@defclass[test-case% object% ()]{ @defclass[test-case% object% ()]{
Instantiated for old-style DrScheme test-case boxes in a @tech{WXME} Instantiated for old-style DrRacket test-case boxes in a @tech{WXME}
stream for text mode. stream for text mode.
@defmethod[(get-comment) (or/c false/c input-port?)]{ @defmethod[(get-comment) (or/c false/c input-port?)]{
@ -610,14 +610,14 @@ Returns a port for the ``error msg'' field, if any.}
@defmethod[(get-enabled?) boolean?]{ @defmethod[(get-enabled?) boolean?]{
Returns @scheme[#t] if the test is enabled.} Returns @racket[#t] if the test is enabled.}
@defmethod[(get-collapsed?) boolean?]{ @defmethod[(get-collapsed?) boolean?]{
Returns @scheme[#t] if the test is collapsed.} Returns @racket[#t] if the test is collapsed.}
@defmethod[(get-error-box?) boolean?]{ @defmethod[(get-error-box?) boolean?]{
Returns @scheme[#t] if the test is for an exception.} Returns @racket[#t] if the test is for an exception.}
} }