1618 lines
61 KiB
Racket
1618 lines
61 KiB
Racket
#lang at-exp scheme/gui
|
|
|
|
(require mred/mred-unit
|
|
mred/mred-sig
|
|
framework/framework-unit
|
|
framework/private/sig
|
|
(for-syntax scheme/base)
|
|
scribble/srcdoc)
|
|
|
|
(require framework/preferences
|
|
framework/test
|
|
framework/gui-utils
|
|
framework/decorated-editor-snip
|
|
framework/private/decorated-editor-snip)
|
|
|
|
(provide (all-from-out framework/preferences
|
|
framework/test
|
|
framework/gui-utils
|
|
framework/decorated-editor-snip
|
|
framework/private/decorated-editor-snip))
|
|
|
|
(require/doc scheme/base scribble/manual framework/private/mapdesc)
|
|
|
|
(provide-signature-elements
|
|
(prefix application: framework:application-class^)
|
|
(prefix version: framework:version-class^)
|
|
(prefix color-model: framework:color-model-class^)
|
|
(prefix mode: framework:mode-class^)
|
|
(prefix exit: framework:exit-class^)
|
|
(prefix menu: framework:menu-class^)
|
|
(prefix preferences: framework:preferences-class^)
|
|
(prefix number-snip: framework:number-snip-class^)
|
|
(prefix autosave: framework:autosave-class^)
|
|
(prefix path-utils: framework:path-utils-class^)
|
|
(prefix icon: framework:icon-class^)
|
|
(prefix keymap: framework:keymap-class^)
|
|
(prefix editor: framework:editor-class^)
|
|
(prefix pasteboard: framework:pasteboard-class^)
|
|
(prefix text: framework:text-class^)
|
|
(prefix color: framework:color^)
|
|
(prefix color-prefs: framework:color-prefs-class^)
|
|
(prefix comment-box: framework:comment-box-class^)
|
|
(prefix finder: framework:finder-class^)
|
|
(prefix group: framework:group-class^)
|
|
(prefix canvas: framework:canvas-class^)
|
|
(prefix panel: framework:panel-class^)
|
|
(prefix frame: framework:frame-class^)
|
|
(prefix handler: framework:handler-class^)
|
|
(prefix scheme: framework:scheme-class^)
|
|
(prefix main: framework:main-class^))
|
|
|
|
(define-values/invoke-unit/infer
|
|
(export framework^)
|
|
(link standard-mred@ framework@))
|
|
|
|
(provide/doc
|
|
|
|
(proc-doc/names
|
|
text:range? (-> any/c boolean?) (arg)
|
|
@{Determines if @scheme[arg] is an instance of the @tt{range} struct.})
|
|
|
|
(proc-doc/names
|
|
text:range-start
|
|
(-> text:range? exact-nonnegative-integer?)
|
|
(range)
|
|
@{Returns the start position of the range.})
|
|
(proc-doc/names
|
|
text:range-end
|
|
(-> text:range? exact-nonnegative-integer?)
|
|
(range)
|
|
@{Returns the end position of the range.})
|
|
(proc-doc/names
|
|
text:range-caret-space?
|
|
(-> text:range? boolean?)
|
|
(range)
|
|
@{Returns a boolean indicating where the caret-space in the range goes. See also @method[text:basic<%> highlight-range].})
|
|
(proc-doc/names
|
|
text:range-style
|
|
(-> text:range? exact-nonnegative-integer?)
|
|
(range)
|
|
@{Returns the style of the range. See also @method[text:basic<%> highlight-range].})
|
|
(proc-doc/names
|
|
text:range-color
|
|
(-> text:range? (or/c string? (is-a?/c color%)))
|
|
(range)
|
|
@{Returns the color of the highlighted range.})
|
|
|
|
(parameter-doc
|
|
text:autocomplete-append-after
|
|
(parameter/c string?)
|
|
suffix
|
|
@{A string that is inserted after a completion is inserted by a
|
|
@scheme[text:autocomplete] instance.
|
|
|
|
Defaults to @scheme[""].})
|
|
|
|
(parameter-doc
|
|
text:autocomplete-limit
|
|
(parameter/c (and/c integer? exact? positive?))
|
|
count
|
|
@{Controls the number of completions visible at a time in the menu
|
|
produced by @scheme[text:autocomplete] instances.
|
|
|
|
Defaults to 15.})
|
|
|
|
(proc-doc/names
|
|
text:get-completions/manuals
|
|
(-> (or/c false/c (listof symbol?)) (listof string?))
|
|
(manuals)
|
|
@{Returns the list of keywords for the manuals from @scheme[manuals]
|
|
by extracting all of the documented exports of the manuals. The
|
|
symbols are meant to be module paths, eg the quoted
|
|
form of the argument to @scheme[require].
|
|
|
|
If @scheme[manuals] is false,
|
|
then all of the documented names are used.})
|
|
|
|
(proc-doc/names
|
|
text:lookup-port-name
|
|
(-> symbol? (or/c (is-a?/c editor:basic<%>) false/c))
|
|
(manuals)
|
|
@{Returns the editor instance whose port-name matches the given symbol. If no
|
|
editor can be found, then returns @scheme[false].})
|
|
|
|
(proc-doc/names
|
|
number-snip:make-repeating-decimal-snip
|
|
(number? boolean? . -> . (is-a?/c snip%))
|
|
(num show-prefix?)
|
|
@{Makes a number snip that shows the decimal expansion for
|
|
@scheme[number] The boolean indicates if a @litchar{#e} prefix
|
|
appears on the number.
|
|
|
|
See also @scheme[number-snip:make-fraction-snip].})
|
|
|
|
(proc-doc/names
|
|
number-snip:make-fraction-snip
|
|
(number? boolean? . -> . (is-a?/c snip%))
|
|
(num show-prefix-in-decimal-view?)
|
|
@{Makes a number snip that shows a fractional view of @scheme[number].
|
|
The boolean indicates if a @litchar{#e} prefix appears on the
|
|
number, when shown in the decimal state.
|
|
|
|
See also @scheme[number-snip:make-repeating-decimal-snip].})
|
|
|
|
(proc-doc/names
|
|
version:add-spec
|
|
(any/c any/c . -> . void?)
|
|
(spec revision)
|
|
@{These two values are appended to the version string. @scheme[write]
|
|
is used to transform them to strings. For example:
|
|
|
|
@scheme[(version:add-spec 's 1)]
|
|
|
|
in version 205 will make the version string be @litchar{205s1}. The
|
|
symbols @scheme['f] and @scheme['d] are used internally for
|
|
framework and drscheme revisions.})
|
|
|
|
(proc-doc/names
|
|
version:version
|
|
(-> string?)
|
|
()
|
|
@{This function returns a string describing the version of this
|
|
application. See also @scheme[version:add-spec].})
|
|
|
|
(parameter-doc
|
|
application:current-app-name
|
|
(parameter/c string?)
|
|
name
|
|
@{This is a parameter specifying the name of the current
|
|
application. It is used in the help menu
|
|
(see @scheme[frame:standard-menus%]) and in frame titles
|
|
(see @scheme[frame:editor%]).
|
|
The first case in the case-lambda returns the current name, and the
|
|
second case in the case-lambda sets the name of the application to
|
|
@scheme[name].})
|
|
|
|
(proc-doc/names
|
|
preferences:put-preferences/gui
|
|
(-> (listof symbol?)
|
|
(listof any/c)
|
|
any)
|
|
(name-list val-list)
|
|
@{Like @scheme[put-preferences], but has more sophisticated error
|
|
handling. In particular, it
|
|
@itemize[
|
|
@item{waits for three consecutive failures before informing the
|
|
user}
|
|
@item{gives the user the opportunity to ``steal'' the lockfile
|
|
after the third failure, and}
|
|
@item{when failures occur, it remembers what its arguments were
|
|
and if any preference save eventually succeeds, all of the
|
|
past failures are also written at that point.}]})
|
|
|
|
(proc-doc/names
|
|
preferences:add-panel
|
|
(-> (or/c string? (cons/c string? (listof string?)))
|
|
(->d ([parent (is-a?/c area-container-window<%>)])
|
|
()
|
|
[_
|
|
(let ([old-children (send parent get-children)])
|
|
(and/c (is-a?/c area-container-window<%>)
|
|
(λ (child)
|
|
(andmap eq?
|
|
(append old-children (list child))
|
|
(send parent get-children)))))])
|
|
void?)
|
|
(labels f)
|
|
@{@scheme[preferences:add-preference-panel] adds the result of
|
|
@scheme[f] with name @scheme[labels] to the preferences dialog box.
|
|
|
|
The labels determine where this preference panel is placed in the
|
|
dialog. If the list is just one string, the preferences panel is
|
|
placed at the top level of the dialog. If there are more strings, a
|
|
hierarchy of nested panels is created and the new panel is added at
|
|
the end. If multiple calls to
|
|
@scheme[preferences:add-preference-panel] pass the same prefix of
|
|
strings, those panels are placed in the same children.
|
|
|
|
When the preference dialog is opened for the first time, the
|
|
function @scheme[f] is called with a panel, and @scheme[f] is
|
|
expected to add a new child panel to it and add whatever preferences
|
|
configuration controls it wants to that panel. Then, @scheme[f]'s
|
|
should return the panel it added.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-editor-checkbox-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a preferences panel for configuring options related to
|
|
editing.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-general-checkbox-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a catch-all preferences panel for options.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-warnings-checkbox-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a preferences panel for configuring options relating to
|
|
warnings.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-scheme-checkbox-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a preferences panel for configuring options related to
|
|
Racket.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-to-warnings-checkbox-panel
|
|
(((is-a?/c vertical-panel%) . -> . void?) . -> . void?)
|
|
(proc)
|
|
@{Saves @scheme[proc] until the preferences panel is created, when it
|
|
is called with the Misc. panel to add new children to the panel.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-to-scheme-checkbox-panel
|
|
(((is-a?/c vertical-panel%) . -> . void?) . -> . void?)
|
|
(proc)
|
|
@{Saves @scheme[proc] until the preferences panel is created, when it
|
|
is called with the Racket preferences panel to add new children to
|
|
the panel.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-to-editor-checkbox-panel
|
|
(((is-a?/c vertical-panel%) . -> . void?) . -> . void?)
|
|
(proc)
|
|
@{Saves @scheme[proc] until the preferences panel is created, when it
|
|
is called with the editor preferences panel to add new children to
|
|
the panel.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-to-general-checkbox-panel
|
|
(((is-a?/c vertical-panel%) . -> . void?) . -> . void?)
|
|
(proc)
|
|
@{Saves @scheme[proc] until the preferences panel is created, when it
|
|
is called with the general preferences panel to add new children to
|
|
the panel.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-font-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a font selection preferences panel to the preferences dialog.})
|
|
|
|
(proc-doc/names
|
|
preferences:show-dialog
|
|
(-> void?)
|
|
()
|
|
@{Shows the preferences dialog.})
|
|
|
|
(proc-doc/names
|
|
preferences:hide-dialog
|
|
(-> void?)
|
|
()
|
|
@{Hides the preferences dialog.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-on-close-dialog-callback
|
|
((-> void?) . -> . void?)
|
|
(cb)
|
|
@{Registers @scheme[cb]. Next time the user clicks the OK button the
|
|
preferences dialog, all of the @scheme[cb] functions are called,
|
|
assuming that each of the callbacks passed to
|
|
@scheme[preferences:add-can-close-dialog-callback] succeed.})
|
|
|
|
(proc-doc/names
|
|
preferences:add-can-close-dialog-callback
|
|
((-> boolean?) . -> . void?)
|
|
(cb)
|
|
@{Registers @scheme[cb]. Next time the user clicks the OK button the
|
|
preferences dialog, all of the @scheme[cb] functions are called. If
|
|
any of them return @scheme[#f], the dialog is not closed.
|
|
|
|
See also @scheme[preferences:add-on-close-dialog-callback].})
|
|
|
|
(proc-doc/names
|
|
autosave:register
|
|
((and/c (is-a?/c autosave:autosavable<%>)
|
|
(is-a?/c editor<%>))
|
|
. -> .
|
|
void?)
|
|
(obj)
|
|
@{Adds @scheme[obj] to the list of objects to be autosaved. When it
|
|
is time to autosave, the @scheme[do-autosave] method of the object
|
|
is called. This method is responsible for performing the autosave.
|
|
|
|
There is no need to de-register an object because the autosaver
|
|
keeps a ``weak'' pointer to the object; i.e., the autosaver does not
|
|
keep an object from garbage collection.})
|
|
|
|
(proc-doc/names
|
|
autosave:restore-autosave-files/gui
|
|
(-> void?)
|
|
()
|
|
@{Opens a GUI to ask the user about recovering any autosave files left
|
|
around from crashes and things.
|
|
|
|
This function doesn't return until the user has finished restoring
|
|
the autosave files. (It uses yield to handle events however.)})
|
|
|
|
(proc-doc/names
|
|
exit:exiting?
|
|
(-> boolean?)
|
|
()
|
|
@{Returns @scheme[#t] to indicate that an exit operation is taking
|
|
place. Does not indicate that the app will actually exit, since the
|
|
user may cancel the exit.
|
|
|
|
See also @scheme[exit:insert-on-callback] and
|
|
@scheme[exit:insert-can?-callback].})
|
|
|
|
(proc-doc/names
|
|
exit:set-exiting
|
|
(boolean? . -> . void?)
|
|
(exiting?)
|
|
@{Sets a flag that affects the result of @scheme[exit:exiting?].})
|
|
|
|
(proc-doc/names
|
|
exit:insert-on-callback
|
|
((-> void?) . -> . (-> void?))
|
|
(callback)
|
|
@{Adds a callback to be called when exiting. This callback must not
|
|
fail. If a callback should stop an exit from happening, use
|
|
@scheme[exit:insert-can?-callback].})
|
|
|
|
(proc-doc/names
|
|
exit:insert-can?-callback
|
|
((-> boolean?) . -> . (-> void?))
|
|
(callback)
|
|
@{Use this function to add a callback that determines if an attempted
|
|
exit can proceed. This callback should not clean up any state,
|
|
since another callback may veto the exit. Use
|
|
@scheme[exit:insert-on-callback] for callbacks that clean up
|
|
state.})
|
|
|
|
(proc-doc/names
|
|
exit:can-exit?
|
|
(-> boolean?)
|
|
()
|
|
@{Calls the ``can-callbacks'' and returns their results. See
|
|
@scheme[exit:insert-can?-callback] for more information.})
|
|
|
|
(proc-doc/names
|
|
exit:on-exit
|
|
(-> void?)
|
|
()
|
|
@{Calls the ``on-callbacks''. See @scheme[exit:insert-on-callback]
|
|
for more information.})
|
|
|
|
(proc-doc/names
|
|
exit:exit
|
|
(-> any)
|
|
()
|
|
@{@scheme[exit:exit] performs four actions:
|
|
@itemize[
|
|
@item{sets the result of the @scheme[exit:exiting?] function to
|
|
@scheme[#t].}
|
|
@item{invokes the exit-callbacks, with @scheme[exit:can-exit?] if
|
|
none of the ``can?'' callbacks return @scheme[#f],}
|
|
@item{invokes @scheme[exit:on-exit] and then}
|
|
@item{queues a callback that calls @scheme[exit]
|
|
(a mzscheme procedure) and (if @scheme[exit] returns) sets the result of
|
|
@scheme[exit:exiting?] back to @scheme[#t].}]})
|
|
|
|
(proc-doc/names
|
|
exit:user-oks-exit
|
|
(-> boolean?)
|
|
()
|
|
@{Opens a dialog that queries the user about exiting. Returns the
|
|
user's decision.})
|
|
|
|
(proc-doc/names
|
|
path-utils:generate-autosave-name
|
|
(string? . -> . string?)
|
|
(filename)
|
|
@{Generates a name for an autosave file from @scheme[filename].})
|
|
|
|
(proc-doc/names
|
|
path-utils:generate-backup-name
|
|
(path? . -> . path?)
|
|
(filename)
|
|
@{Generates a name for an backup file from @scheme[filename].})
|
|
|
|
(parameter-doc
|
|
finder:dialog-parent-parameter
|
|
(parameter/c (or/c false/c (is-a?/c dialog%) (is-a?/c frame%)))
|
|
parent
|
|
@{This parameter determines the parent of the dialogs created by
|
|
@scheme[finder:get-file], @scheme[finder:put-file],
|
|
@scheme[finder:common-get-file], @scheme[finder:common-put-file],
|
|
@scheme[finder:common-get-file-list], @scheme[finder:std-get-file],
|
|
and @scheme[finder:std-put-file].})
|
|
|
|
(parameter-doc
|
|
finder:default-extension
|
|
(parameter/c string?)
|
|
extension
|
|
@{This parameter controls the default extension for the framework's
|
|
@scheme[finder:put-file] dialog. Its value gets passed as the
|
|
@scheme[default-extension] argument to @scheme[put-file].
|
|
|
|
Its default value is @scheme[""].})
|
|
|
|
(parameter-doc
|
|
finder:default-filters
|
|
(parameter/c (listof (list/c string? string?)))
|
|
filters
|
|
@{
|
|
This parameter controls the default filters for the framework's
|
|
@scheme[finder:put-file] dialog. Its value gets passed as the
|
|
@scheme[default-filters] argument to @scheme[put-file].
|
|
|
|
Its default value is @scheme['(("Any" "*.*"))].})
|
|
|
|
(proc-doc/names
|
|
finder:common-put-file
|
|
(->* ()
|
|
(string?
|
|
(or/c false/c path?)
|
|
boolean?
|
|
string?
|
|
(or/c false/c byte-regexp?)
|
|
string?
|
|
(or/c (is-a?/c top-level-window<%>) false/c))
|
|
(or/c false/c path?))
|
|
(()
|
|
((name "Untitled")
|
|
(directory #f)
|
|
(replace? #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent (finder:dialog-parent-parameter))))
|
|
@{This procedure queries the user for a single filename, using a
|
|
platform-independent dialog box. Consider using
|
|
@scheme[finder:put-file] instead of this function.})
|
|
|
|
(proc-doc/names
|
|
finder:common-get-file
|
|
(->* ()
|
|
((or/c path? false/c)
|
|
string?
|
|
(or/c byte-regexp? false/c)
|
|
string?
|
|
(or/c false/c (is-a?/c top-level-window<%>)))
|
|
(or/c path? false/c))
|
|
(()
|
|
((directory #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent #f)))
|
|
@{This procedure queries the user for a single filename, using a
|
|
platform-independent dialog box. Consider using
|
|
@scheme[finder:get-file] instead of this function.})
|
|
|
|
(proc-doc/names
|
|
finder:std-put-file
|
|
(->* ()
|
|
(string?
|
|
(or/c false/c path?)
|
|
boolean?
|
|
string?
|
|
(or/c false/c byte-regexp?)
|
|
string?
|
|
(or/c (is-a?/c top-level-window<%>) false/c))
|
|
(or/c false/c path?))
|
|
(()
|
|
((name "Untitled")
|
|
(directory #f)
|
|
(replace? #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent (finder:dialog-parent-parameter))))
|
|
@{This procedure queries the user for a single filename, using a
|
|
platform-dependent dialog box. Consider using
|
|
@scheme[finder:put-file] instead of this function.})
|
|
|
|
(proc-doc/names
|
|
finder:std-get-file
|
|
(->* ()
|
|
((or/c path? false/c)
|
|
string?
|
|
(or/c byte-regexp? false/c)
|
|
string?
|
|
(or/c false/c (is-a?/c top-level-window<%>)))
|
|
(or/c path? false/c))
|
|
(()
|
|
((directory #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent #f)))
|
|
@{This procedure queries the user for a single filename, using a
|
|
platform-dependent dialog box. Consider using
|
|
@scheme[finder:get-file] instead of this function.})
|
|
|
|
(proc-doc/names
|
|
finder:put-file
|
|
(->* ()
|
|
(string?
|
|
(or/c false/c path?)
|
|
boolean?
|
|
string?
|
|
(or/c false/c byte-regexp?)
|
|
string?
|
|
(or/c (is-a?/c top-level-window<%>) false/c))
|
|
(or/c false/c path?))
|
|
(()
|
|
((name "Untitled")
|
|
(directory #f)
|
|
(replace? #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent (finder:dialog-parent-parameter))))
|
|
@{Queries the user for a filename.
|
|
|
|
If the result of @scheme[(preferences:get 'framework:file-dialogs)]
|
|
is @scheme['std] this calls @scheme[finder:std-put-file], and if it
|
|
is @scheme['common], @scheme[finder:common-put-file] is called.})
|
|
|
|
(proc-doc/names
|
|
finder:get-file
|
|
(->* ()
|
|
((or/c path? false/c)
|
|
string?
|
|
(or/c byte-regexp? string? false/c)
|
|
string?
|
|
(or/c false/c (is-a?/c top-level-window<%>)))
|
|
(or/c path? false/c))
|
|
(()
|
|
((directory #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent #f)))
|
|
@{Queries the user for a filename.
|
|
|
|
If the result of @scheme[(preferences:get 'framework:file-dialogs)]
|
|
is @scheme['std] this calls @scheme[finder:std-get-file], and if it
|
|
is @scheme['common], @scheme[finder:common-get-file] is called.})
|
|
|
|
(proc-doc/names
|
|
finder:common-get-file-list
|
|
(->* ()
|
|
((or/c false/c path?)
|
|
string?
|
|
(or/c false/c byte-regexp?)
|
|
string?
|
|
(or/c false/c (is-a?/c top-level-window<%>)))
|
|
(or/c (listof path?) false/c))
|
|
(()
|
|
((directory #f)
|
|
(prompt "Select File")
|
|
(filter #f)
|
|
(filter-msg "That filename does not have the right form.")
|
|
(parent #f)))
|
|
@{This procedure queries the user for a list of filenames, using a
|
|
platform-independent dialog box.})
|
|
|
|
(proc-doc/names
|
|
frame:setup-size-pref
|
|
(symbol? number? number? . -> . void)
|
|
(size-pref-sym width height)
|
|
@{Initializes a preference for the @scheme[frame:size-pref] mixin.
|
|
|
|
The first argument should be the preferences symbol, and the second
|
|
an third should be the default width and height, respectively.})
|
|
|
|
(proc-doc/names
|
|
frame:add-snip-menu-items
|
|
(->* ((is-a?/c menu%) (subclass?/c menu-item%))
|
|
((-> (is-a?/c menu-item%) void?))
|
|
void?)
|
|
((menu menu-item%)
|
|
((func void)))
|
|
@{Inserts three menu items into @scheme[menu], one that inserts a text
|
|
box, one that inserts a pasteboard box, and one that inserts an
|
|
image into the currently focused editor (if there is one). Uses
|
|
@scheme[menu-item%] as the class for the menu items.
|
|
|
|
Calls @scheme[func] right after inserting each menu item.})
|
|
|
|
(proc-doc/names
|
|
frame:reorder-menus
|
|
((is-a?/c frame%) . -> . void?)
|
|
(frame)
|
|
@{Re-orders the menus in a frame. It moves the ``File'' and ``Edit''
|
|
menus to the front of the menubar and moves the ``Windows'' and
|
|
``Help'' menus to the end of the menubar.
|
|
|
|
This is useful in conjunction with the frame classes. After
|
|
instantiating the class and adding ones own menus, the menus will be
|
|
mis-ordered. This function fixes them up.})
|
|
|
|
(proc-doc/names
|
|
frame:remove-empty-menus
|
|
((is-a?/c frame%) . -> . void?)
|
|
(frame)
|
|
@{Removes empty menus in a frame.})
|
|
|
|
(parameter-doc
|
|
frame:current-icon
|
|
(parameter/c (or/c #f
|
|
(is-a?/c bitmap%)
|
|
(cons/c (is-a?/c bitmap%)
|
|
(is-a?/c bitmap%))))
|
|
icon-spec
|
|
@{The value of this parameter is used by the initialization code of
|
|
@scheme[frame:basic-mixin].
|
|
@itemize[@item{If it is @scheme[#f], then its value is
|
|
ignored.}
|
|
@item{It it is a @scheme[bitmap%], then the @method[frame% set-icon] is called
|
|
with the bitmap, the result of invoking the @scheme[bitmap% get-loaded-mask] method,
|
|
and @scheme['both].}
|
|
@item{If it is a pair of bitmaps, then the @method[frame% set-icon]
|
|
method is invoked twice, once with each bitmap in the pair. The first bitmap
|
|
is passed (along with the result of its @scheme[bitmap% get-loaded-mask])
|
|
and @scheme['small], and then the second bitmap is passed
|
|
(also along with the result of its @scheme[bitmap% get-loaded-mask]) and @scheme['large].}]
|
|
|
|
Defaults to @scheme[#f].})
|
|
|
|
(proc-doc/names
|
|
group:get-the-frame-group
|
|
(-> (is-a?/c group:%))
|
|
()
|
|
@{This returns the frame group.})
|
|
|
|
(proc-doc/names
|
|
group:on-close-action
|
|
(-> void?)
|
|
()
|
|
@{See also @scheme[group:can-close-check].
|
|
|
|
Call this function from the @method[top-level-window<%> can-close?]
|
|
callback of a frame in order for the group to properly close the
|
|
application.})
|
|
|
|
(proc-doc/names
|
|
group:can-close-check
|
|
(-> boolean?)
|
|
()
|
|
@{See also @scheme[group:on-close-action].
|
|
|
|
Call this function from the @method[top-level-window<%> can-close?]
|
|
callback of a frame in order for the group to properly close the
|
|
application.})
|
|
|
|
(proc-doc/names
|
|
group:add-to-windows-menu
|
|
(-> (-> (is-a?/c menu%) any) any)
|
|
(proc)
|
|
@{Procedures passed to this function are called when the @onscreen{Windows} menu is
|
|
created. Use it to add additional menu items.})
|
|
|
|
(proc-doc/names
|
|
handler:handler?
|
|
(any/c . -> . boolean?)
|
|
(obj)
|
|
@{This predicate determines if its input is a handler.})
|
|
|
|
(proc-doc/names
|
|
handler:handler-name
|
|
(handler:handler? . -> . string?)
|
|
(handler)
|
|
@{Extracts the name from a handler.})
|
|
|
|
(proc-doc/names
|
|
handler:handler-extension
|
|
(handler:handler?
|
|
. -> . (or/c (path? . -> . boolean?) (listof string?)))
|
|
(handler)
|
|
@{Extracts the extension from a handler.})
|
|
|
|
(proc-doc/names
|
|
handler:handler-handler
|
|
(handler:handler? . -> . (path? . -> . (is-a?/c frame:editor<%>)))
|
|
(handler)
|
|
@{Extracs the handler's handling function.})
|
|
|
|
(proc-doc/names
|
|
handler:insert-format-handler
|
|
(string?
|
|
(or/c string? (listof string?) (path? . -> . boolean?))
|
|
(path? . -> . (or/c false/c (is-a?/c frame:editor<%>)))
|
|
. -> .
|
|
void?)
|
|
(name pred handler)
|
|
@{This function inserts a format handler.
|
|
|
|
The string, @scheme[name] names the format handler for use with
|
|
@scheme[handler:find-named-format-handler]. If @scheme[pred] is a
|
|
string, it is matched with the extension of a filename by
|
|
@scheme[handler:find-format-handler]. If @scheme[pred] is a list of
|
|
strings, they are each matched with the extension of a filename by
|
|
@scheme[handler:find-format-handler]. If it is a function, the
|
|
filename is applied to the function and the functions result
|
|
determines if this is the handler to use.
|
|
|
|
The most recently added format handler takes precedence over all
|
|
other format handlers.})
|
|
|
|
(proc-doc/names
|
|
handler:find-named-format-handler
|
|
(string? . -> . (path? . -> . (is-a?/c frame:editor<%>)))
|
|
(name)
|
|
@{This function selects a format handler. See also
|
|
@scheme[handler:insert-format-handler].
|
|
|
|
It finds a handler based on @scheme[name].})
|
|
|
|
(proc-doc/names
|
|
handler:find-format-handler
|
|
(path? . -> . (path? . -> . (is-a?/c frame:editor<%>)))
|
|
(filename)
|
|
@{This function selects a format handler. See also
|
|
@scheme[handler:insert-format-handler].
|
|
|
|
It finds a handler based on @scheme[filename].})
|
|
|
|
(proc-doc/names
|
|
handler:edit-file
|
|
(->* ((or/c path? false/c))
|
|
((-> (is-a?/c frame:editor<%>)))
|
|
(or/c false/c (is-a?/c frame:editor<%>)))
|
|
((filename)
|
|
((make-default
|
|
(λ () ((handler:current-create-new-window) filename)))))
|
|
@{This function creates a frame or re-uses an existing frame to edit a
|
|
file.
|
|
|
|
If the preference @scheme['framework:open-here] is set to
|
|
@scheme[#t], and
|
|
@scheme[(send (group:get-the-frame-group) get-open-here-frame)]
|
|
returns a frame, the
|
|
@method[frame:open-here<%> open-here] method of that frame is used
|
|
to load the file in the existing frame.
|
|
|
|
Otherwise, it invokes the appropriate format handler to open the
|
|
file (see @scheme[handler:insert-format-handler]).
|
|
|
|
@itemize[
|
|
@item{If @scheme[filename] is a string, this function checks the
|
|
result of @scheme[group:get-the-frame-group] to see if the
|
|
@scheme[filename] is already open by a frame in the group.
|
|
@itemize[
|
|
@item{If so, it returns the frame.}
|
|
@item{If not, this function calls
|
|
@scheme[handler:find-format-handler] with
|
|
@scheme[filename].
|
|
@itemize[
|
|
@item{If a handler is found, it is applied to
|
|
@scheme[filename] and it's result is the
|
|
final result.}
|
|
@item{If not, @scheme[make-default] is used.}]}]}
|
|
@item{If @scheme[filename] is @scheme[#f], @scheme[make-default]
|
|
is used.}]})
|
|
|
|
(parameter-doc
|
|
handler:current-create-new-window
|
|
(parameter/c (-> (or/c false/c path?) (is-a?/c frame%)))
|
|
proc
|
|
@{This is a parameter that controls how the framework creates new
|
|
application windows.
|
|
|
|
The default setting is this:
|
|
@schemeblock[
|
|
(λ (filename)
|
|
(let ([frame (make-object frame:text-info-file% filename)])
|
|
(send frame show #t)
|
|
frame))
|
|
]})
|
|
|
|
(proc-doc/names
|
|
handler:open-file
|
|
(->* ()
|
|
((or/c false/c path? string?))
|
|
(or/c false/c (is-a?/c frame:basic<%>)))
|
|
(()
|
|
((dir #f)))
|
|
@{This function queries the user for a filename and opens the file for
|
|
editing. It uses @scheme[handler:edit-file] to open the file, once
|
|
the user has chosen it.
|
|
|
|
Calls @scheme[finder:get-file] and @scheme[handler:edit-file], passing along @scheme[dir].})
|
|
|
|
(proc-doc/names
|
|
handler:install-recent-items
|
|
((is-a?/c menu%) . -> . void?)
|
|
(menu)
|
|
@{This function deletes all of the items in the given menu and adds
|
|
one menu item for each recently opened file. These menu items, when
|
|
selected, call @scheme[handler:edit-file] with the filename of the
|
|
recently opened file.
|
|
|
|
The menu's size is limited to 10.})
|
|
|
|
(proc-doc/names
|
|
handler:set-recent-items-frame-superclass
|
|
((implementation?/c frame:standard-menus<%>) . -> . void?)
|
|
(frame)
|
|
@{Sets the superclass for the recently opened files frame. It must be
|
|
derived from @scheme[frame:standard-menus].})
|
|
|
|
(proc-doc/names
|
|
handler:add-to-recent
|
|
(path? . -> . void?)
|
|
(filename)
|
|
@{Adds a filename to the list of recently opened files.})
|
|
|
|
(proc-doc/names
|
|
handler:set-recent-position
|
|
(path? number? number? . -> . void?)
|
|
(filename start end)
|
|
@{Sets the selection of the recently opened file to @scheme[start] and
|
|
@scheme[end].})
|
|
|
|
(proc-doc/names
|
|
handler:size-recently-opened-files
|
|
(number? . -> . void?)
|
|
(num)
|
|
@{Sizes the @scheme['framework:recently-opened-files/pos] preference
|
|
list length to @scheme[num].})
|
|
|
|
(proc-doc/names
|
|
icon:get-paren-highlight-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns the parenthesis highlight @scheme[bitmap%]. It is only
|
|
used on black and white screens.})
|
|
|
|
(proc-doc/names
|
|
icon:get-eof-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns the @scheme[bitmap%] used for the clickable ``eof''
|
|
icon from @scheme[text:ports].})
|
|
|
|
(proc-doc/names
|
|
icon:get-autowrap-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns the autowrap's @scheme[bitmap%].
|
|
|
|
The bitmap may not respond @scheme[#t] to the @method[bitmap% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-lock-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns the lock's @scheme[bitmap].
|
|
|
|
The bitmap may not respond @scheme[#t] to the @method[bitmap% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-unlock-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns the reset unlocked @scheme[bitmap].
|
|
|
|
The bitmap may not respond @scheme[#t] to the @method[bitmap% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-anchor-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns the anchor's @scheme[bitmap].
|
|
|
|
The bitmap may not respond @scheme[#t] to the @method[bitmap% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-left/right-cursor
|
|
(-> (is-a?/c cursor%))
|
|
()
|
|
@{This function returns a @scheme[cursor%] object that indicates
|
|
left/right sizing is possible, for use with columns inside a window.
|
|
|
|
The cursor may not respond @scheme[#t] to the @method[cursor% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-up/down-cursor
|
|
(-> (is-a?/c cursor%))
|
|
()
|
|
@{This function returns a @scheme[cursor%] object that indicates
|
|
up/down sizing is possible, for use with columns inside a window.
|
|
|
|
The cursor may not respond @scheme[#t] to the @method[cursor% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-gc-on-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns a bitmap to be displayed in an @scheme[frame:info<%>]
|
|
frame when garbage collection is taking place.
|
|
|
|
The bitmap may not respond @scheme[#t] to the @method[bitmap% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
icon:get-gc-off-bitmap
|
|
(-> (is-a?/c bitmap%))
|
|
()
|
|
@{This returns a bitmap to be displayed in an @scheme[frame:info<%>]
|
|
frame when garbage collection is not taking place.
|
|
|
|
The bitmap may not respond @scheme[#t] to the @method[bitmap% ok?]
|
|
method.})
|
|
|
|
(proc-doc/names
|
|
keymap:remove-user-keybindings-file
|
|
(-> any/c any)
|
|
(user-keybindings-path)
|
|
@{Removes the keymap previously added by
|
|
@scheme[keymap:add-user-keybindings-file].})
|
|
|
|
(proc-doc/names
|
|
keymap:add-user-keybindings-file
|
|
(-> any/c any)
|
|
(user-keybindings-path-or-require-spec)
|
|
@{Chains the keymap defined by
|
|
@scheme[user-keybindings-path-or-require-spec] to the global keymap,
|
|
returned by @scheme[keymap:get-global].
|
|
|
|
If @scheme[user-keybindings-path-or-require-spec] is a path, the
|
|
module is loaded directly from that path. Otherwise,
|
|
@scheme[user-keybindings-path-or-require-spec] is treated like an
|
|
argument to @scheme[require].})
|
|
|
|
(parameter-doc
|
|
keymap:add-to-right-button-menu
|
|
(parameter/c
|
|
(-> (is-a?/c popup-menu%)
|
|
(is-a?/c editor<%>)
|
|
(is-a?/c event%)
|
|
void?))
|
|
proc
|
|
@{When the keymap that @scheme[keymap:get-global] returns is installed
|
|
into an editor, this parameter's value is used for right button
|
|
clicks.
|
|
|
|
Before calling this procedure, the function
|
|
@scheme[append-editor-operation-menu-items] is called.
|
|
|
|
See also @scheme[keymap:add-to-right-button-menu/before].})
|
|
|
|
(parameter-doc
|
|
keymap:add-to-right-button-menu/before
|
|
(parameter/c
|
|
(-> (is-a?/c popup-menu%) (is-a?/c editor<%>) (is-a?/c event%) void?))
|
|
proc
|
|
@{When the keymap that @scheme[keymap:get-global] returns is installed
|
|
into an editor, this function is called for right button clicks.
|
|
|
|
After calling this procedure, the function
|
|
@scheme[append-editor-operation-menu-items] is called.
|
|
|
|
See also @scheme[keymap:add-to-right-button-menu].})
|
|
|
|
(proc-doc/names
|
|
keymap:call/text-keymap-initializer
|
|
((-> any/c) . -> . any/c)
|
|
(thunk-proc)
|
|
@{Thus function parameterizes the call to @scheme[thunk-proc] by
|
|
setting the keymap-initialization procedure (see
|
|
@scheme[current-text-keymap-initializer]) to install the framework's
|
|
standard text bindings.})
|
|
|
|
(proc-doc/names
|
|
keymap:canonicalize-keybinding-string
|
|
(string? . -> . string?)
|
|
(keybinding-string)
|
|
@{Returns a string that denotes the same keybindings as the input
|
|
string, except that it is in canonical form; two canonical
|
|
keybinding strings can be compared with @scheme[string=?].})
|
|
|
|
(proc-doc/names
|
|
keymap:get-editor
|
|
(-> (is-a?/c keymap%))
|
|
()
|
|
@{This returns a keymap for handling standard editing operations. It
|
|
binds these keys:
|
|
|
|
@itemize[
|
|
@item{@scheme["z"]: undo}
|
|
@item{@scheme["y"]: redo}
|
|
@item{@scheme["x"]: cut}
|
|
@item{@scheme["c"]: copy}
|
|
@item{@scheme["v"]: paste}
|
|
@item{@scheme["a"]: select all}]
|
|
where each key is prefixed with the menu-shortcut key, based on the
|
|
platform. Under unix, the shortcut is @scheme["a:"]; under windows
|
|
the shortcut key is @scheme["c:"] and under MacOS, the shortcut key
|
|
is @scheme["d:"].})
|
|
|
|
(proc-doc/names
|
|
keymap:get-file
|
|
(-> (is-a?/c keymap%))
|
|
()
|
|
@{This returns a keymap for handling file operations.})
|
|
|
|
(proc-doc/names
|
|
keymap:get-user
|
|
(-> (is-a?/c keymap%))
|
|
()
|
|
@{This returns a keymap that contains all of the keybindings in the keymaps loaded via @scheme[keymap:add-user-keybindings-file]})
|
|
|
|
|
|
(proc-doc/names
|
|
keymap:get-global
|
|
(-> (is-a?/c keymap%))
|
|
()
|
|
@{This returns a keymap for general operations. See
|
|
@scheme[keymap:setup-global] for a list of the bindings this keymap
|
|
contains.})
|
|
|
|
(proc-doc/names
|
|
keymap:get-search
|
|
(-> (is-a?/c keymap%))
|
|
()
|
|
@{This returns a keymap for searching operations.})
|
|
|
|
(proc-doc/names
|
|
keymap:make-meta-prefix-list
|
|
(string? . -> . (listof string?))
|
|
(key)
|
|
@{This prefixes a key with all of the different meta prefixes and
|
|
returns a list of the prefixed strings.
|
|
|
|
takes a keymap, a base key specification, and a function name; it
|
|
prefixes the base key with all ``meta'' combination prefixes, and
|
|
installs the new combinations into the keymap. For example,
|
|
@scheme[(keymap:send-map-function-meta keymap "a" func)] maps
|
|
@scheme["m:a"] and @scheme["ESC;a"] to @scheme[func].})
|
|
|
|
(proc-doc/names
|
|
keymap:send-map-function-meta
|
|
((is-a?/c keymap%) string? string? . -> . void?)
|
|
(keymap key func)
|
|
@{@index{Meta} Most keyboard and mouse mappings are inserted into a
|
|
keymap by calling the keymap's @method[keymap% map-function] method.
|
|
However, ``meta'' combinations require special attention. The
|
|
@scheme["m:"] prefix recognized by @method[keymap% map-function]
|
|
applies only to the Meta key that exists on some keyboards. By
|
|
convention, however, ``meta'' combinations can also be accessed by
|
|
using ``ESC'' as a prefix.
|
|
|
|
This procedure binds all of the key-bindings obtained by prefixing
|
|
@scheme[key] with a meta-prefix to @scheme[func] in
|
|
@scheme[keymap].})
|
|
|
|
(proc-doc/names
|
|
keymap:setup-editor
|
|
((is-a?/c keymap%) . -> . void?)
|
|
(keymap)
|
|
@{This sets up the input keymap with the bindings described in
|
|
@scheme[keymap:get-editor].})
|
|
|
|
(proc-doc/names
|
|
keymap:setup-file
|
|
((is-a?/c keymap%) . -> . void?)
|
|
(keymap)
|
|
@{This extends a @scheme[keymap%] with the bindings for files.})
|
|
|
|
(proc-doc/names
|
|
keymap:setup-global
|
|
((is-a?/c keymap%) . -> . void?)
|
|
(keymap)
|
|
@{This extends a @scheme[keymap%] with the general bindings.
|
|
|
|
This function extends a @scheme[keymap%] with the following
|
|
functions:
|
|
@itemize[
|
|
@item{@mapdesc[ring-bell any] --- Rings the bell
|
|
(using @scheme[bell]) and removes the search panel from the frame,
|
|
if there.}
|
|
@item{@mapdesc[save-file key] --- Saves the buffer. If the buffer
|
|
has no name, then
|
|
@scheme[finder:put-file]@index["finder:put-file"] is
|
|
invoked.}
|
|
@item{@mapdesc[save-file-as key] --- Calls
|
|
@scheme[finder:put-file]@index["finder:put-file"] to save
|
|
the buffer.}
|
|
@item{@mapdesc[load-file key] --- Invokes
|
|
@scheme[finder:open-file]@index["finder:open-file"].}
|
|
@item{@mapdesc[find-string key] --- Opens the search buffer at the
|
|
bottom of the frame, unless it is already open, in which
|
|
case it searches for the text in the search buffer.}
|
|
@item{@mapdesc[find-string-reverse key] --- Same as
|
|
``find-string'', but in the reverse direction.}
|
|
@item{@mapdesc[find-string-replace key] --- Opens a replace string
|
|
dialog box.}
|
|
@item{@mapdesc[toggle-anchor key] --- Turns selection-anchoring on
|
|
or off.}
|
|
@item{@mapdesc[center-view-on-line key] --- Centers the buffer in
|
|
its display using the currently selected line.}
|
|
@item{@mapdesc[collapse-space key] --- Collapses all non-return
|
|
whitespace around the caret into a single space.}
|
|
@item{@mapdesc[remove-space key] --- Removes all non-return
|
|
whitespace around the caret.}
|
|
@item{@mapdesc[collapse-newline key] --- Collapses all empty lines
|
|
around the caret into a single empty line. If there is only
|
|
one empty line, it is removed.}
|
|
@item{@mapdesc[open-line key] --- Inserts a new line.}
|
|
@item{@mapdesc[transpose-chars key] --- Transposes the characters
|
|
before and after the caret and moves forward one position.}
|
|
@item{@mapdesc[transpose-words key] --- Transposes words before
|
|
and after the caret and moves forward one word.}
|
|
@item{@mapdesc[capitalize-word key] --- Changes the first
|
|
character of the next word to a capital letter and moves to
|
|
the end of the word.}
|
|
@item{@mapdesc[upcase-word key] --- Changes all characters of the
|
|
next word to capital letters and moves to the end of the
|
|
word.}
|
|
@item{@mapdesc[downcase-word key] --- Changes all characters
|
|
of the next word to lowercase letters and moves to the end
|
|
of the word.}
|
|
@item{@mapdesc[kill-word key] --- Kills the next word.}
|
|
@item{@mapdesc[backward-kill-word key] --- Kills the previous
|
|
word.}
|
|
@item{@mapdesc[goto-line any] --- Queries the user for a line
|
|
number and moves the caret there.}
|
|
@item{@mapdesc[goto-position any] --- Queries the user for a
|
|
position number and moves the caret there.}
|
|
@item{@mapdesc[copy-clipboard mouse] --- Copies the current
|
|
selection to the clipboard.}
|
|
@item{@mapdesc[cut-clipboard mouse] --- Cuts the current selection
|
|
to the clipboard.}
|
|
@item{@mapdesc[paste-clipboard mouse] --- Patses the clipboard to
|
|
the current selection.}
|
|
@item{@mapdesc[copy-click-region mouse] --- Copies the region
|
|
between the caret and the input mouse event.}
|
|
@item{@mapdesc[cut-click-region mouse] --- Cuts the region
|
|
between the caret and the input mouse event.}
|
|
@item{@mapdesc[paste-click-region mouse] --- Pastes the clipboard
|
|
into the position of the input mouse event.}
|
|
@item{@mapdesc[select-click-word mouse] --- Selects the word under
|
|
the input mouse event.}
|
|
@item{@mapdesc[select-click-line mouse] --- Selects the line under
|
|
the input mouse event.}
|
|
@item{@mapdesc[start-macro key] -- Starts building a keyboard
|
|
macro}
|
|
@item{@mapdesc[end-macro key] --- Stops building a keyboard macro}
|
|
@item{@mapdesc[do-macro key] --- Executes the last keyboard macro}
|
|
@item{@mapdesc[toggle-overwrite key] --- Toggles overwriting
|
|
mode}]
|
|
|
|
These functions are bound to the following keys
|
|
(C = control, S = shift, A = alt, M = ``meta'', D = command):
|
|
|
|
@itemize[
|
|
@item{C-g : ``ring-bell''}
|
|
@item{M-C-g : ``ring-bell''}
|
|
@item{C-c C-g : ``ring-bell''}
|
|
@item{C-x C-g : ``ring-bell''}
|
|
@item{C-p : ``previous-line''}
|
|
@item{S-C-p : ``select-previous-line''}
|
|
@item{C-n : ``next-line''}
|
|
@item{S-C-n : ``select-next-line''}
|
|
@item{C-e : ``end-of-line''}
|
|
@item{S-C-e : ``select-to-end-of-line''}
|
|
@item{D-RIGHT : ``end-of-line''}
|
|
@item{S-D-RIGHT : ``select-to-end-of-line''}
|
|
@item{M-RIGHT : ``end-of-line''}
|
|
@item{S-M-RIGHT : ``select-to-end-of-line''}
|
|
@item{C-a : ``beginning-of-line''}
|
|
@item{S-C-a : ``select-to-beginning-of-line''}
|
|
@item{D-LEFT : ``beginning-of-line''}
|
|
@item{D-S-LEFT : ``select-to-beginning-of-line''}
|
|
@item{M-LEFT : ``beginning-of-line''}
|
|
@item{M-S-LEFT : ``select-to-beginning-of-line''}
|
|
@item{C-h : ``delete-previous-character''}
|
|
@item{C-d : ``delete-next-character''}
|
|
@item{C-f : ``forward-character''}
|
|
@item{S-C-f : ``select-forward-character''}
|
|
@item{C-b : ``backward-character''}
|
|
@item{S-C-b : ``select-backward-character''}
|
|
@item{M-f : ``forward-word''}
|
|
@item{S-M-f : ``select-forward-word''}
|
|
@item{A-RIGHT : ``forward-word''}
|
|
@item{A-S-RIGHT : ``forward-select-word''}
|
|
@item{M-b : ``backward-word''}
|
|
@item{S-M-b : ``select-backward-word''}
|
|
@item{A-LEFT : ``backward-word''}
|
|
@item{A-S-LEFT : ``backward-select-word''}
|
|
@item{M-d : ``kill-word''}
|
|
@item{M-DELETE : ``backward-kill-word''}
|
|
@item{M-c : ``capitalize-word''}
|
|
@item{M-u : ``upcase-word''}
|
|
@item{M-l : ``downcase-word''}
|
|
@item{M-< : ``beginning-of-file''}
|
|
@item{S-M-< : ``select-to-beginning-of-file''}
|
|
@item{M-> : ``end-of-file''}
|
|
@item{S-M-> : ``select-to-end-of-file''}
|
|
@item{C-v : ``next-page''}
|
|
@item{S-C-v : ``select-next-page''}
|
|
@item{M-v : ``previous-page''}
|
|
@item{S-M-v : ``select-previous-page''}
|
|
@item{C-l : ``center-view-on-line''}
|
|
@item{C-k : ``delete-to-end-of-line''}
|
|
@item{C-y : ``paste-clipboard'' (Except Windows)}
|
|
@item{A-v : ``paste-clipboard''}
|
|
@item{D-v : ``paste-clipboard''}
|
|
@item{C-_ : ``undo''}
|
|
@item{C-x u : ``undo''}
|
|
@item{C-+ : ``redo''}
|
|
@item{C-w : ``cut-clipboard''}
|
|
@item{M-w : ``copy-clipboard''}
|
|
@item{C-x C-s : ``save-file''}
|
|
@item{C-x C-w : ``save-file-as''}
|
|
@item{C-x C-f : ``load-file''}
|
|
@item{C-s : ``find-string''}
|
|
@item{C-r : ``find-string-reverse''}
|
|
@item{M-% : ``find-string-replace''}
|
|
@item{SPACE : ``collapse-space''}
|
|
@item{M-Backslash : ``remove-space''}
|
|
@item{C-x C-o : ``collapse-newline''}
|
|
@item{C-o : ``open-line''}
|
|
@item{C-t : ``transpose-chars''}
|
|
@item{M-t : ``transpose-words''}
|
|
@item{C-SPACE : ``toggle-anchor''}
|
|
@item{M-g : ``goto-line''}
|
|
@item{M-p : ``goto-position''}
|
|
@item{LEFTBUTTONTRIPLE : ``select-click-line''}
|
|
@item{LEFTBUTTONDOUBLE : ``select-click-word''}
|
|
@item{RIGHTBUTTON : ``copy-click-region''}
|
|
@item{RIGHTBUTTONDOUBLE : ``cut-click-region''}
|
|
@item{MIDDLEBUTTON : ``paste-click-region''}
|
|
@item{C-RIGHTBUTTON : ``copy-clipboard''}
|
|
@item{INSERT : ``toggle-overwrite''}
|
|
@item{M-o : ``toggle-overwrite''}]})
|
|
|
|
(proc-doc/names
|
|
keymap:setup-search
|
|
((is-a?/c keymap%) . -> . void?)
|
|
(keymap)
|
|
@{This extends a @scheme[keymap%] with the bindings for searching.})
|
|
|
|
(proc-doc/names
|
|
keymap:set-chained-keymaps
|
|
((is-a?/c keymap:aug-keymap<%>)
|
|
(listof (is-a?/c keymap%))
|
|
. -> .
|
|
void?)
|
|
(keymap children-keymaps)
|
|
@{Sets @scheme[keymap]'s chained keymaps to @scheme[children-keymaps],
|
|
unchaining any keymaps that are currently chained to
|
|
@scheme[keymap].})
|
|
|
|
(proc-doc/names
|
|
keymap:remove-chained-keymap
|
|
((is-a?/c editor<%>)
|
|
(is-a?/c keymap:aug-keymap<%>)
|
|
. -> .
|
|
void?)
|
|
(editor keymap)
|
|
@{Removes @scheme[keymap] from the keymaps chained to @scheme[editor].
|
|
Also (indirectly) removes all keymaps chained to @scheme[keymap]
|
|
from @scheme[editor], since they are removed when unchaining
|
|
@scheme[keymap] itself.
|
|
|
|
Each of the keymaps chained to @scheme[editor] must be an
|
|
@scheme[keymap:aug-keymap%] and @scheme[keymap] cannot be the result
|
|
of @scheme[(send editor get-keymap)] That is, @scheme[keymap] must
|
|
be chained to some keymap attached to the editor.})
|
|
|
|
(proc-doc/names
|
|
scheme:text-balanced?
|
|
(->* ((is-a?/c text%))
|
|
(number? (or/c false/c number?))
|
|
boolean?)
|
|
((text)
|
|
((start 0) (end #f)))
|
|
@{Determines if the range in the editor from @scheme[start] to
|
|
@scheme[end] in @scheme[text] has at least one complete s-expression and
|
|
there are no incomplete s-expressions. If
|
|
@scheme[end] is @scheme[#f], it defaults to the last position of the
|
|
@scheme[text].
|
|
|
|
The implementation of this function creates a port with
|
|
@scheme[open-input-text-editor] and then uses `read' to parse the
|
|
range of the buffer.})
|
|
|
|
(proc-doc/names
|
|
scheme:add-preferences-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a tabbing preferences panel to the preferences dialog.})
|
|
|
|
(proc-doc/names
|
|
scheme:get-keymap
|
|
(-> (is-a?/c keymap%))
|
|
()
|
|
@{Returns a keymap with binding suitable for Racket.})
|
|
|
|
(proc-doc/names
|
|
scheme:add-coloring-preferences-panel
|
|
(-> any)
|
|
()
|
|
@{
|
|
Installs the ``Racket'' preferences panel in the ``Syntax Coloring''
|
|
section.})
|
|
|
|
(proc-doc/names
|
|
scheme:get-color-prefs-table
|
|
(-> (listof (list/c symbol? (is-a?/c color%))))
|
|
()
|
|
@{Returns
|
|
a table mapping from symbols
|
|
(naming the categories that the online colorer uses for Racket mode coloring) to their colors.
|
|
|
|
These symbols are suitable for input to
|
|
@scheme[scheme:short-sym->pref-name] and
|
|
@scheme[scheme:short-sym->style-name].
|
|
|
|
See also @scheme[scheme:get-white-on-black-color-prefs-table].})
|
|
|
|
(proc-doc/names
|
|
scheme:get-white-on-black-color-prefs-table
|
|
(-> (listof (list/c symbol? (is-a?/c color%))))
|
|
()
|
|
@{Returns
|
|
a table mapping from symbols
|
|
(naming the categories that the online colorer uses for Racket mode coloring) to their colors when
|
|
the user chooses the white-on-black mode in the preferences dialog.
|
|
|
|
See also @scheme[scheme:get-color-prefs-table].})
|
|
|
|
(proc-doc/names
|
|
scheme:short-sym->pref-name
|
|
(symbol? . -> . symbol?)
|
|
(short-sym)
|
|
@{Builds the symbol naming the preference from one of the symbols in
|
|
the table returned by @scheme[scheme:get-color-prefs-table].})
|
|
|
|
(proc-doc/names
|
|
scheme:short-sym->style-name
|
|
(symbol? . -> . string?)
|
|
(short-sym)
|
|
@{Builds the symbol naming the editor style from one of the symbols in
|
|
the table returned by @scheme[scheme:get-color-prefs-table]. This
|
|
style is a named style in the style list returned by
|
|
@scheme[editor:get-standard-style-list].})
|
|
|
|
(proc-doc/names
|
|
scheme:get-wordbreak-map
|
|
(-> (is-a?/c editor-wordbreak-map%))
|
|
()
|
|
@{This method returns a @scheme[editor-wordbreak-map%] that is suitable
|
|
for Racket.})
|
|
|
|
(proc-doc/names
|
|
scheme:init-wordbreak-map
|
|
((is-a?/c keymap%) . -> . void?)
|
|
(key)
|
|
@{Initializes the workdbreak map for @scheme[keymap].})
|
|
|
|
(proc-doc/names
|
|
scheme:setup-keymap
|
|
((is-a?/c keymap%) . -> . void?)
|
|
(keymap)
|
|
@{Initializes @scheme[keymap] with Racket-mode keybindings.})
|
|
|
|
(proc-doc/names
|
|
editor:set-default-font-color
|
|
(-> (is-a?/c color%) void?)
|
|
(color)
|
|
@{Sets the color of the style named
|
|
@scheme[editor:get-default-color-style-name].})
|
|
|
|
(proc-doc/names
|
|
editor:get-default-color-style-name
|
|
(-> string?)
|
|
()
|
|
@{The name of the style (in the list returned by
|
|
@scheme[editor:get-standard-style-list]) that holds the default
|
|
color.})
|
|
|
|
(proc-doc/names
|
|
editor:set-standard-style-list-delta
|
|
(string? (is-a?/c style-delta%) . -> . void?)
|
|
(name delta)
|
|
@{Finds (or creates) the style named by @scheme[name] in the result of
|
|
@scheme[editor:get-standard-style-list] and sets its delta to
|
|
@scheme[delta].
|
|
|
|
If the style named by @scheme[name] is already in the style list, it
|
|
must be a delta style.})
|
|
|
|
(proc-doc/names
|
|
editor:set-standard-style-list-pref-callbacks
|
|
(-> any)
|
|
()
|
|
@{Installs the font preference callbacks that update the style list
|
|
returned by @scheme[editor:get-standard-style-list] based on the
|
|
font preference symbols.})
|
|
|
|
(proc-doc/names
|
|
editor:get-standard-style-list
|
|
(-> (is-a?/c style-list%))
|
|
()
|
|
@{Returns a style list that is used for all instances of
|
|
@scheme[editor:standard-style-list%].})
|
|
|
|
(proc-doc/names
|
|
editor:add-after-user-keymap
|
|
(-> (is-a?/c keymap%) (listof (is-a?/c keymap%)) (listof (is-a?/c keymap%)))
|
|
(keymap keymaps)
|
|
@{Returns a list that contains all of the keymaps in @scheme[keymaps], in the
|
|
same relative order, but also with @scheme[keymap], where @scheme[keymap]
|
|
is now the first keymap after @scheme[keymap:get-user] (if that keymap is
|
|
in the list.)})
|
|
|
|
(proc-doc/names
|
|
color-model:rgb->xyz
|
|
(number? number? number? . -> . color-model:xyz?)
|
|
(r g b)
|
|
@{Converts a color represented as a red-green-blue tuple (each value
|
|
from 0 to 255) into an XYZ tuple. This describes a point in the CIE
|
|
XYZ color space.})
|
|
|
|
(proc-doc/names
|
|
color-model:rgb-color-distance
|
|
(number? number? number? number? number? number? . -> . number?)
|
|
(red-a green-a blue-a red-b green-b blue-b)
|
|
@{This calculates a distance between two colors. The smaller the
|
|
distance, the closer the colors should appear to the human eye. A
|
|
distance of 10 is reasonably close that it could be called the same
|
|
color.
|
|
|
|
This function is not symmetric in red, green, and blue, so it is
|
|
important to pass red, green, and blue components of the colors in
|
|
the proper order. The first three arguments are red, green and
|
|
blue for the first color, respectively, and the second three
|
|
arguments are red green and blue for the second color,
|
|
respectively.})
|
|
|
|
(proc-doc/names
|
|
color-model:xyz->rgb
|
|
(number? number? number? . -> . (list/c number? number? number?))
|
|
(x y z)
|
|
@{Converts an XYZ-tuple (in the CIE XYZ colorspace) into a list of
|
|
values representing an RGB-tuple.})
|
|
|
|
(proc-doc/names
|
|
color-model:xyz?
|
|
(any/c . -> . boolean?)
|
|
(val)
|
|
@{Determines if @scheme[val] an xyz color record.})
|
|
|
|
(proc-doc/names
|
|
color-model:xyz-x
|
|
(color-model:xyz? . -> . number?)
|
|
(xyz)
|
|
@{Extracts the x component of @scheme[xyz].})
|
|
|
|
(proc-doc/names
|
|
color-model:xyz-y
|
|
(color-model:xyz? . -> . number?)
|
|
(xyz)
|
|
@{Extracts the y component of @scheme[xyz].})
|
|
|
|
(proc-doc/names
|
|
color-model:xyz-z
|
|
(color-model:xyz? . -> . number?)
|
|
(xyz)
|
|
@{Extracts the z component of @scheme[xyz].})
|
|
|
|
(proc-doc/names
|
|
color-prefs:set-default/color-scheme
|
|
(-> symbol?
|
|
(or/c (is-a?/c color%) string?)
|
|
(or/c (is-a?/c color%) string?)
|
|
void?)
|
|
(pref-sym black-on-white-color white-on-black-color)
|
|
@{Registers a preference whose value will be updated when the user
|
|
clicks on one of the color scheme default settings in the
|
|
preferences dialog.
|
|
|
|
Also calls @scheme[preferences:set-default] and
|
|
@scheme[preferences:set-un/marshall] with appropriate arguments to
|
|
register the preference.})
|
|
|
|
(proc-doc/names
|
|
color-prefs:register-color-preference
|
|
(->* (symbol? string? (or/c (is-a?/c color%) (is-a?/c style-delta%)))
|
|
((or/c string? (is-a?/c color%) false/c))
|
|
void?)
|
|
((pref-name style-name color/sd)
|
|
((white-on-black-color #f)))
|
|
@{This function registers a color preference and initializes the style
|
|
list returned from @scheme[editor:get-standard-style-list]. In
|
|
particular, it calls @scheme[preferences:set-default] and
|
|
@scheme[preferences:set-un/marshall] to install the pref for
|
|
@scheme[pref-name], using @scheme[color/sd] as the default
|
|
color. The preference is bound to a @scheme[style-delta%], and
|
|
initially the @scheme[style-delta%] changes the foreground color to
|
|
@scheme[color/sd], unless @scheme[color/sd] is a style delta
|
|
already, in which case it is just used directly. Then, it calls
|
|
@scheme[editor:set-standard-style-list-delta] passing the
|
|
@scheme[style-name] and the current value of the preference
|
|
@scheme[pref-name].
|
|
|
|
Finally, it adds calls @scheme[preferences:add-callback] to set a
|
|
callback for @scheme[pref-name] that updates the style list when the
|
|
preference changes.
|
|
|
|
If @scheme[white-on-black-color] is not @scheme[#f], then the color
|
|
of the @scheme[color/sd] argument is used in combination with
|
|
@scheme[white-on-black-color] to register this preference with
|
|
@scheme[color-prefs:set-default/color-scheme].})
|
|
|
|
(proc-doc/names
|
|
color-prefs:add-background-preferences-panel
|
|
(-> void?)
|
|
()
|
|
@{Adds a preferences panel that configures the background color for
|
|
@scheme[editor:basic-mixin].})
|
|
|
|
(proc-doc/names
|
|
color-prefs:add-to-preferences-panel
|
|
(string? ((is-a?/c vertical-panel%) . -> . void?) . -> . void?)
|
|
(name func)
|
|
@{Calls @scheme[func] with the subpanel of the preferences coloring
|
|
panel that corresponds to @scheme[name].})
|
|
|
|
(proc-doc/names
|
|
color-prefs:build-color-selection-panel
|
|
((is-a?/c area-container<%>) symbol? string? string? . -> . void?)
|
|
(parent pref-sym style-name example-text)
|
|
@{Builds a panel with a number of controls for configuring a font: the
|
|
color and check boxes for bold, italic, and underline. The
|
|
@scheme[parent] argument specifies where the panel will be placed.
|
|
The @scheme[pref-sym] should be a preference
|
|
(suitable for use with @scheme[preferences:get] and @scheme[preferences:set]).
|
|
The
|
|
@scheme[style-name] specifies the name of a style in the style list
|
|
returned from @scheme[editor:get-standard-style-list] and
|
|
@scheme[example-text] is shown in the panel so users can see the
|
|
results of their configuration.})
|
|
|
|
(proc-doc/names
|
|
color-prefs:marshall-style-delta
|
|
(-> (is-a?/c style-delta%) printable/c)
|
|
(style-delta)
|
|
@{Builds a printed representation for a style-delta.})
|
|
|
|
(proc-doc/names
|
|
color-prefs:unmarshall-style-delta
|
|
(-> printable/c (or/c false/c (is-a?/c style-delta%)))
|
|
(marshalled-style-delta)
|
|
@{Builds a style delta from its printed representation. Returns
|
|
@scheme[#f] if the printed form cannot be parsed.})
|
|
|
|
(proc-doc/names
|
|
color-prefs:white-on-black
|
|
(-> any)
|
|
()
|
|
@{Sets the colors registered by @scheme[color-prefs:register-color-preference] to their white-on-black variety. })
|
|
|
|
(proc-doc/names
|
|
color-prefs:black-on-white
|
|
(-> any)
|
|
()
|
|
@{Sets the colors registered by @scheme[color-prefs:register-color-preference] to their black-on-white variety. }))
|