diff --git a/collects/scribblings/gui/eventspace-funcs.scrbl b/collects/scribblings/gui/eventspace-funcs.scrbl
index af3a26fc17..511630d5a8 100644
--- a/collects/scribblings/gui/eventspace-funcs.scrbl
+++ b/collects/scribblings/gui/eventspace-funcs.scrbl
@@ -67,7 +67,7 @@ Returns a list of visible top-level frames and dialogs in the current
 }
 
 @defproc[(get-top-level-focus-window)
-         (or/c @scheme[frame%] or @scheme[dialog%] object false/c)]{
+         (or/c (is-a?/c frame%) (is-a?/c dialog%) false/c)]{
 Returns the top level window in the current eventspace that has the
  keyboard focus (or contains the window with the keyboard focus), or
  @scheme[#f] if no window in the current eventspace has the focus.
@@ -75,7 +75,7 @@ Returns the top level window in the current eventspace that has the
 }
 
 @defproc[(get-top-level-edit-target-window)
-         (or/c @scheme[frame%] or @scheme[dialog%] object false/c)]{
+         (or/c (is-a?/c frame%) (is-a?/c dialog%) false/c)]{
 Returns the top level window in the current eventspace that is visible
  and most recently had the keyboard focus (or contains the window that
  had the keyboard focus), or @scheme[#f] if there is no visible window
diff --git a/collects/scribblings/gui/miscwin-funcs.scrbl b/collects/scribblings/gui/miscwin-funcs.scrbl
index e86b2a0f9d..525620cf8e 100644
--- a/collects/scribblings/gui/miscwin-funcs.scrbl
+++ b/collects/scribblings/gui/miscwin-funcs.scrbl
@@ -18,15 +18,15 @@
 
 Changes the cursor to a watch cursor for all windows in the current eventspace.
 Use 
-@scheme[end-busy-cursor] to revert the cursor back to its previous state. Calls to
-@scheme[begin-busy-cursor] and 
-@scheme[end-busy-cursor] can be nested arbitrarily.
+@racket[end-busy-cursor] to revert the cursor back to its previous state. Calls to
+@racket[begin-busy-cursor] and 
+@racket[end-busy-cursor] can be nested arbitrarily.
 
 The cursor installed by 
-@scheme[begin-busy-cursor] overrides any window-specific cursors installed with
+@racket[begin-busy-cursor] overrides any window-specific cursors installed with
 @method[window<%> set-cursor].
 
-See also @scheme[is-busy?].
+See also @racket[is-busy?].
 }
 
 @defproc[(bell) void?]{
@@ -34,7 +34,7 @@ Rings the system bell.
 }
 
 @defproc[(end-busy-cursor) void?]{
-See @scheme[begin-busy-cursor].
+See @racket[begin-busy-cursor].
 }
 
 @defproc*[([(file-creator-and-type [filename path]
@@ -51,7 +51,7 @@ See @scheme[begin-busy-cursor].
 
 Gets or sets the creator and type of a file in Mac OS X.
 
-The get operation always returns @scheme[#"????"] and @scheme[#"????"] for
+The get operation always returns @racket[#"????"] and @racket[#"????"] for
  Unix or Windows. The set operation has no effect under Unix or
  Windows.
 }
@@ -60,17 +60,17 @@ The get operation always returns @scheme[#"????"] and @scheme[#"????"] for
          (or/c path? false/c)]{
 
 Finds a platform-specific (and possibly user- or machine-specific)
- standard filename or directory. See also @scheme[find-system-path].
+ standard filename or directory. See also @racket[find-system-path].
 
-The result depends on @scheme[what], and a @scheme[#f] result is only
- possible when @scheme[what] is @scheme['x-display]:
+The result depends on @racket[what], and a @racket[#f] result is only
+ possible when @racket[what] is @racket['x-display]:
 
 @itemize[
 
- @item{@scheme['init-file] returns the path to the user-specific
- initialization file (containing Scheme code). The directory part of
- the path is the same path as returned for @scheme['init-dir] by
- Racket's @scheme[find-system-path].  The file name is
+ @item{@racket['init-file] returns the ,path to the user-specific
+ initialization file (containing Racket code). The directory part of
+ the path is the same path as returned for @racket['init-dir] by
+ Racket's @racket[find-system-path].  The file name is
  platform-specific:
   @itemize[
 
@@ -79,14 +79,14 @@ The result depends on @scheme[what], and a @scheme[#f] result is only
 
   ]}
 
- @item{@scheme['setup-file] returns the path to the file
- containing resources used by @scheme[get-resource]; obsolete.}
+ @item{@racket['setup-file] returns the path to the file
+ containing resources used by @racket[get-resource]; obsolete.}
 
- @item{@scheme['x-display] returns a ``path'' whose string identifies
+ @item{@racket['x-display] returns a ``path'' whose string identifies
  the X display if specified by either the @Flag{display} flag or the
  @envvar{DISPLAY} environment variable when GRacket starts under X. For
  other platforms, or when neither @Flag{display} nor @envvar{DISPLAY}
- was specified, the result is @scheme[#f].}
+ was specified, the result is @racket[#f].}
 
 ]
 
@@ -101,9 +101,9 @@ Returns an immutable list specifying the default prefix for menu
 shortcuts. See also
 @xmethod[selectable-menu-item<%> get-shortcut-prefix].
 
-Under Windows, the default is @scheme['(ctl)]. Under Mac OS X, the
-default is @scheme['(cmd)]. Under X, the default is normally
-@scheme['(ctl)], but the default can be changed through the
+Under Windows, the default is @racket['(ctl)]. Under Mac OS X, the
+default is @racket['(cmd)]. Under X, the default is normally
+@racket['(ctl)], but the default can be changed through the
 @Resource{defaultMenuPrefix} low-level preference (see
 @|mrprefsdiscuss|).}
 
@@ -122,52 +122,52 @@ Returns the background color of a panel (usually some shade of gray)
          boolean?]{
 
 Gets a resource value from the resource database. The resource value
- is keyed on the combination of @scheme[section] and @scheme[entry].  The
- return value is @scheme[#t] if a value is found, @scheme[#f] if it is
- not. The type of the value initially in the @scheme[value] box
- determines the way that the resource is interpreted, and @scheme[value]
+ is keyed on the combination of @racket[section] and @racket[entry].  The
+ return value is @racket[#t] if a value is found, @racket[#f] if it is
+ not. The type of the value initially in the @racket[value] box
+ determines the way that the resource is interpreted, and @racket[value]
  is filled with a new value of the same type if one is found.
 
-If @scheme[file] is @scheme[#f], platform-specific resource files
- are read, as determined by @scheme[find-graphical-system-path]
- with @indexed-scheme['setup-file]. (Under X, when @scheme[file] is
- @scheme[#f], the user's @filepath{.Xdefaults} file is also read, or the
+If @racket[file] is @racket[#f], platform-specific resource files
+ are read, as determined by @racket[find-graphical-system-path]
+ with @indexed-racket['setup-file]. (Under X, when @racket[file] is
+ @racket[#f], the user's @filepath{.Xdefaults} file is also read, or the
  file specified by the @filepath{XENVIRONMENT} environment variable.)
 
 The format of a resource entry depends on the platform. Windows
  resources use the standard @filepath{.ini} format. X and Mac OS X
  resources use the standard X resource format, where each entry
- consists of a @scheme[section].@scheme[entry] resource name, a colon, and
+ consists of a @racket[section].@racket[entry] resource name, a colon, and
  the resource value, terminated by a newline.  Section and entry names are
  case-sensitive.
 
 @index['("registry")]{@index['("Windows registry")]{Under}} Windows, if
- @scheme[section] is one of the following strings, then @scheme[file]
- is ignored, and @scheme[entry] is used as a resource path:
+ @racket[section] is one of the following strings, then @racket[file]
+ is ignored, and @racket[entry] is used as a resource path:
 
 @itemize[
 
- @item{@indexed-scheme["HKEY_CLASSES_ROOT"]}
- @item{@indexed-scheme["HKEY_CURRENT_CONFIG"]}
- @item{@indexed-scheme["HKEY_CURRENT_USER"]}
- @item{@indexed-scheme["HKEY_LOCAL_MACHINE"]}
- @item{@indexed-scheme["HKEY_USERS"]}
+ @item{@indexed-racket["HKEY_CLASSES_ROOT"]}
+ @item{@indexed-racket["HKEY_CURRENT_CONFIG"]}
+ @item{@indexed-racket["HKEY_CURRENT_USER"]}
+ @item{@indexed-racket["HKEY_LOCAL_MACHINE"]}
+ @item{@indexed-racket["HKEY_USERS"]}
 
 ]
 
-In that case, the @scheme[entry] argument is parsed as a resource entry
+In that case, the @racket[entry] argument is parsed as a resource entry
 path, followed by a backslash, followed by a value name. To get the
 ``default'' value for an entry, use the empty name. For example, the
 following expression gets a command line for starting a browser:
 
-@schemeblock[
+@racketblock[
 (let ([b (box "")])
   (get-resource "HKEY_CLASSES_ROOT"
                 "htmlfile\\shell\\open\\command\\" b)
   (unbox b))
 ]
 
-See also @scheme[write-resource].}
+See also @racket[write-resource].}
 
 @defproc[(get-window-text-extent [string string]
                                  [font (is-a?/c font%)]
@@ -176,7 +176,7 @@ See also @scheme[write-resource].}
                  exact-nonnegative-integer?)]{
 
 Returns the pixel size of a string drawn as a window's label or value
-when drawn with the given font. The optional @scheme[combine?]
+when drawn with the given font. The optional @racket[combine?]
 argument is as for @xmethod[dc<%> get-text-extent].
 
 See also @xmethod[dc<%> get-text-extent].
@@ -186,57 +186,57 @@ See also @xmethod[dc<%> get-text-extent].
                                          [redirect-ports? any/c (not eval-eventspace)])
          void?]{
 
-Similar to @scheme[read-eval-print-loop], except that none of
- @scheme[read-eval-print-loop]'s configuration parameters are used (such
- as @scheme[current-read]) and the interaction occurs in a GUI window
+Similar to @racket[read-eval-print-loop], except that none of
+ @racket[read-eval-print-loop]'s configuration parameters are used (such
+ as @racket[current-read]) and the interaction occurs in a GUI window
  instead of using the current input and output ports.
 
 Expressions entered into the graphical read-eval-print loop can be
  evaluated in an eventspace (and thread) that is distinct from the one
- implementing the @scheme[graphical-read-eval-print-loop]
+ implementing the @racket[graphical-read-eval-print-loop]
  window (i.e., the current eventspace when
- @scheme[graphical-read-eval-print-loop] is called).
+ @racket[graphical-read-eval-print-loop] is called).
 
-If no eventspace is provided, or if @scheme[#f] is provided, an
- evaluation eventspace is created using @scheme[(make-eventspace)]
+If no eventspace is provided, or if @racket[#f] is provided, an
+ evaluation eventspace is created using @racket[(make-eventspace)]
  with a new custodian; the eventspace and its threads are be shut down
- when the user closes the @scheme[graphical-read-eval-print-loop]
+ when the user closes the @racket[graphical-read-eval-print-loop]
  window. If an eventspace is provided, closing the window performs no
  shut-down actions on eventspace.
 
-When @scheme[redirect-ports?] is true, the following parameters are
+When @racket[redirect-ports?] is true, the following parameters are
  initialized in the created eventspace's handler thread:
 @itemize[
 
- @item{@scheme[current-output-port] --- writes to the frame}
- @item{@scheme[current-error-port] --- writes to the frame}
- @item{@scheme[current-input-port] --- always returns @scheme[eof]}
+ @item{@racket[current-output-port] --- writes to the frame}
+ @item{@racket[current-error-port] --- writes to the frame}
+ @item{@racket[current-input-port] --- always returns @racket[eof]}
 
 ]
 
 The keymap for the read-eval-print loop's editor is initialized by
  calling the current keymap initializer procedure, which is determined
  by the
-@scheme[current-text-keymap-initializer] parameter.
+@racket[current-text-keymap-initializer] parameter.
 }
 
 @defproc[(textual-read-eval-print-loop) void?]{
 
-Similar to @scheme[read-eval-print-loop], except that evaluation uses
+Similar to @racket[read-eval-print-loop], except that evaluation uses
  a newly created eventspace.
 
-The @scheme[current-prompt-read] parameter is used in the current
+The @racket[current-prompt-read] parameter is used in the current
  thread to read input. The result is queued for evaluation and
  printing in the created eventspace's @tech{handler thread}, which
- uses @scheme[current-eval] and @scheme[current-print]. After printing
+ uses @racket[current-eval] and @racket[current-print]. After printing
  completes for an interaction result, the next expression in read in
  the original thread, and so on.
 
-If an @scheme[exn:break] exception is raised in the original thread
-during reading, it aborts the current call to @scheme[(current-read)]
-and a new one is started. If an @scheme[exn:break] exception is raised
+If an @racket[exn:break] exception is raised in the original thread
+during reading, it aborts the current call to @racket[(current-read)]
+and a new one is started. If an @racket[exn:break] exception is raised
 in the original thread while waiting for an interaction to complete, a
-break is sent (via @scheme[break-thread]) to the created eventspace's
+break is sent (via @racket[break-thread]) to the created eventspace's
 @tech{handler thread}.}
 
 
@@ -249,14 +249,14 @@ Hides the cursor until the user moves the mouse or clicks the mouse
 
 @defproc[(is-busy?) boolean?]{
 
-Returns @scheme[#t] if a busy cursor has been installed with
-@scheme[begin-busy-cursor] and not removed with
-@scheme[end-busy-cursor].
+Returns @racket[#t] if a busy cursor has been installed with
+@racket[begin-busy-cursor] and not removed with
+@racket[end-busy-cursor].
 }
 
 @defproc[(label->plain-label [label string]) string?]{
 
-Strips shortcut ampersands from @scheme[label], removes parenthesized
+Strips shortcut ampersands from @racket[label], removes parenthesized
  ampersand--character combinations along with any surrounding space,
  and removes anything after a tab. Overall, it returns the label as it would
  appear on a button on a platform without support for mnemonics.
@@ -266,14 +266,14 @@ Strips shortcut ampersands from @scheme[label], removes parenthesized
 
 @defproc[(make-gui-empty-namespace) namespace?]{
 
-Like @scheme[make-base-empty-namespace], but with
-@scheme[scheme/class] and @schememodname[scheme/gui/base] also
+Like @racket[make-base-empty-namespace], but with
+@racket[racket/class] and @racketmodname[racket/gui/base] also
 attached to the result namespace.}
 
 @defproc[(make-gui-namespace) namespace?]{
 
-Like @scheme[make-base-namespace], but with @scheme[scheme/class] and
-@schememodname[scheme/gui/base] also required into the top-level
+Like @racket[make-base-namespace], but with @racket[racket/class] and
+@racketmodname[racket/gui/base] also required into the top-level
 environment of the result namespace.}
 
 
@@ -281,9 +281,9 @@ environment of the result namespace.}
                      [async? any/c])
          boolean?]{
 
-Plays a sound file. If @scheme[async?] is false, the function does not
+Plays a sound file. If @racket[async?] is false, the function does not
  return until the sound completes. Otherwise, it returns immediately.
- The result is @scheme[#t] if the sound plays successfully, @scheme[#f]
+ The result is @racket[#t] if the sound plays successfully, @racket[#f]
  otherwise.
 
 Under Windows, only @filepath{.wav} files are supported.
@@ -322,17 +322,17 @@ Under Mac OS X, Quicktime is used to play sounds; most sound
                      [argument-list list? null])
          any/c]{
 
-Sends an AppleEvent or raises @scheme[exn:fail:unsupported].
+Sends an AppleEvent or raises @racket[exn:fail:unsupported].
 
-The @scheme[receiver-bytes], @scheme[event-class-bytes], and
-@scheme[event-id-bytes] arguments specify the signature of the
+The @racket[receiver-bytes], @racket[event-class-bytes], and
+@racket[event-id-bytes] arguments specify the signature of the
 receiving application, the class of the AppleEvent, and the ID of
 the AppleEvent.
 
-The @scheme[direct-arg-v] value is converted (see below) and passed as
-the main argument of the event; if @scheme[direct-argument-v] is
+The @racket[direct-arg-v] value is converted (see below) and passed as
+the main argument of the event; if @racket[direct-argument-v] is
 @|void-const|, no main argument is sent in the event. The
-@scheme[argument-list] argument is a list of two-element lists
+@racket[argument-list] argument is a list of two-element lists
 containing a typestring and value; each typestring is used ad the
 keyword name of an AppleEvent argument for the associated converted
 value. 
@@ -341,35 +341,35 @@ The following types of Racket values can be converted to AppleEvent
 values passed to the receiver:
 
 @atable[
-(tline @elem{@scheme[#t] or @scheme[#f]}  @elem{Boolean})
+(tline @elem{@racket[#t] or @racket[#f]}  @elem{Boolean})
 (tline @elem{small integer}   @elem{Long Integer})
 (tline @elem{inexact real number} @elem{Double})
 (tline @elem{string} @elem{Characters})
 (tline @elem{list of convertible values}  @elem{List of converted values})
-(tline @scheme[#(file _pathname)]   @elem{Alias (file exists) or FSSpec (does not exist)})
-(tline @scheme[#(record (_typestring _v) ...)]   @elem{Record of keyword-tagged values})
+(tline @racket[#(file _pathname)]   @elem{Alias (file exists) or FSSpec (does not exist)})
+(tline @racket[#(record (_typestring _v) ...)]   @elem{Record of keyword-tagged values})
 ]
 
-If other types of values are passed to @scheme[send-event] for
+If other types of values are passed to @racket[send-event] for
  conversion, the @exnraise[exn:fail:unsupported].
 
-The @scheme[send-event] procedure does not return until the receiver
-of the AppleEvent replies. The result of @scheme[send-event] is the
+The @racket[send-event] procedure does not return until the receiver
+of the AppleEvent replies. The result of @racket[send-event] is the
 reverse-converted reply value (see below), or the @exnraise[exn:fail]
 if there is an error. If there is no error or return value,
-@scheme[send-event] returns @|void-const|.
+@racket[send-event] returns @|void-const|.
 
 The following types of AppleEvent values can be reverse-converted into
-a Racket value returned by @scheme[send-event]:
+a Racket value returned by @racket[send-event]:
 
 @atable[
-(tline @elem{Boolean}  @elem{@scheme[#t] or @scheme[#f]})
+(tline @elem{Boolean}  @elem{@racket[#t] or @racket[#f]})
 (tline @elem{Signed Integer}  @elem{integer})
 (tline @elem{Float, Double, or Extended}  @elem{inexact real number})
 (tline @elem{Characters}  @elem{string})
 (tline @elem{List of reverse-convertible values}  @elem{list of reverse-converted values})
-(tline @elem{Alias or FSSpec}  @scheme[#(file _pathname)])
-(tline @elem{Record of keyword-tagged values}  @scheme[#(record (_typestring _v) ...)])
+(tline @elem{Alias or FSSpec}  @racket[#(file _pathname)])
+(tline @elem{Record of keyword-tagged values}  @racket[#(record (_typestring _v) ...)])
 ]
 
 If the AppleEvent reply contains a value that cannot be
@@ -383,34 +383,34 @@ If the AppleEvent reply contains a value that cannot be
          any/c]{
 
 @index['("drag-and-drop")]{Finds} the frontmost top-level window at
- (@scheme[x], @scheme[y]) in global coordinates. If a window is there,
+ (@racket[x], @racket[y]) in global coordinates. If a window is there,
  this function calls the window's @method[top-level-window<%>
- on-message] method, providing @scheme[message] as the method's
+ on-message] method, providing @racket[message] as the method's
  argument; the result of the function call is the result returned by
- the method. If no Scheme window is at the given coordinates, or if it
- is covered by a non-Scheme window at (@scheme[x], @scheme[y]),
- @scheme[#f] is returned.
+ the method. If no Racket window is at the given coordinates, or if it
+ is covered by a non-Racket window at (@racket[x], @racket[y]),
+ @racket[#f] is returned.
 }
 
 
 @defproc[(system-position-ok-before-cancel?) boolean?]{
 
-Returns @scheme[#t] under Windows---indicating that a dialog with
+Returns @racket[#t] under Windows---indicating that a dialog with
 @onscreen{OK} and @onscreen{Cancel} buttons should place the
 @onscreen{OK} button on to left of the @onscreen{Cancel} button---and
-returns @scheme[#f] under Mac OS X and X.}
+returns @racket[#f] under Mac OS X and X.}
 
 
 @defthing[the-clipboard (is-a?/c clipboard<%>)]{
 
-See @scheme[clipboard<%>].
+See @racket[clipboard<%>].
 
 
 }
 
 @defthing[the-x-selection-clipboard (is-a?/c clipboard<%>)]{
 
-See @scheme[clipboard<%>].
+See @racket[clipboard<%>].
 
 
 }
@@ -422,29 +422,29 @@ See @scheme[clipboard<%>].
          boolean?]{
 
 Writes a resource value to the specified resource database. The
- resource value is keyed on the combination of @scheme[section] and
- @scheme[entry], with the same special handling of @scheme[entry] for
- under Windows as for @scheme[get-resource].
+ resource value is keyed on the combination of @racket[section] and
+ @racket[entry], with the same special handling of @racket[entry] for
+ under Windows as for @racket[get-resource].
 
-If @scheme[file] is @scheme[#f], the platform-specific resource
+If @racket[file] is @racket[#f], the platform-specific resource
  database is read, as determined by
- @scheme[find-graphical-system-path] with
- @indexed-scheme['setup-file].
+ @racket[find-graphical-system-path] with
+ @indexed-racket['setup-file].
 
-The return value is @scheme[#t] if the write succeeds, @scheme[#f]
+The return value is @racket[#t] if the write succeeds, @racket[#f]
  otherwise. (A failure indicates that the resource file cannot be
  written.)
 
-If @scheme[value] is an integer outside a platform-specific range,
+If @racket[value] is an integer outside a platform-specific range,
  @|MismatchExn|.
 
-See also @scheme[get-resource].}
+See also @racket[get-resource].}
 
 @defproc[(label-string? [v any/c]) boolean?]{
-  Returns @scheme[#t] if @scheme[v] is a string whose length is less than or equal to @scheme[200].                                             
+  Returns @racket[#t] if @racket[v] is a string whose length is less than or equal to @racket[200].                                             
 }
 
 @defproc[(key-code-symbol? [v any/c]) boolean?]{
-  Returns @scheme[#t] if the argument is a symbol that can be returned by
-  @scheme[key-event%]'s method @method[key-event% get-key-code].
+  Returns @racket[#t] if the argument is a symbol that can be returned by
+  @racket[@key-event%]'s method @method[key-event% get-key-code].
 }
diff --git a/collects/scribblings/gui/system-menu-funcs.scrbl b/collects/scribblings/gui/system-menu-funcs.scrbl
index 95b0bf50eb..4390444554 100644
--- a/collects/scribblings/gui/system-menu-funcs.scrbl
+++ b/collects/scribblings/gui/system-menu-funcs.scrbl
@@ -45,7 +45,7 @@ user selects the application @onscreen{About} menu item in Mac OS
 X.  The thunk is always called in the initial eventspace's
 handler thread (as a callback).
 
-The default handler displays a generic PLT Scheme dialog.
+The default handler displays a generic Racket dialog.
 
 If the current eventspace is not the initial eventspace, this
 procedure returns @scheme[void] (when called with zero arguments)