12 Frame
|
Classes matching this interface support the basic frame% functionality required by the framework.
(send a-frame:basic get-area-container%)
The class that this method returns is used to create the area-container<%> in this frame.
(send a-frame:basic get-area-container)
→ (instance (is-a?/c area-container<%>))
This returns the main area-container<%> in the frame
(send a-frame:basic get-menu-bar%) → (subclass?/c menu-bar%)
The result of this method is used to create the initial menu bar for this frame.
Return menu-bar%.
(send a-frame:basic make-root-area-container
class
parent)
→ (instance (is-a?/c area-container<%>))
class : (is-a?/c area-container<%>)
parent : (instance (is-a?/c area-container<%>))
Override this method to insert a panel in between the panel used by the clients of this frame and the frame itself. For example, to insert a status line panel override this method with something like this:
(class ...
(rename [super-make-root-area-container make-root-area-container])
[status-panel #f])
(define/override (make-root-area-container cls parent)
(set! status-panel
(super-make-root-area-container vertical-panel% parent))
(let ([root (make-object cls status-panel)])
root))
...)
In this example, status-panel will contain a root panel for the other classes, and whatever panels are needed to display status information.
The searching frame is implemented using this method.
Calls make-object with class and parent.
This method closes the frame by calling the can-close?, on-close, and show methods.
It’s implementation is:
(inherit can-close? on-close)
[show
(lambda ()
(when (can-close?)
(on-close)
(show #f)))])
(send a-frame:basic editing-this-file? filename) → boolean
filename : path
Indicates if this frame contains this buffer (and can edit that file).
Returns #f.
(send a-frame:basic get-filename [temp]) → (union |#f| path)
temp : (union |#f| (box boolean)) = |#f|
This returns the filename that the frame is currently being saved as, or #f if there is no appropriate filename.
Defaultly returns #f.
If temp is a box, it is filled with #t or #f, depending if the filename is a temporary filename.
(send a-frame:basic make-visible filename) → void
filename : string
Makes the file named by filename visible (intended for use with tabbed editing).
frame:basic-mixin : (class? . -> . class?) | ||
| ||
|
This mixin provides the basic functionality that the framework expects. It helps manage the list of frames in the group:% object returned by group:get-the-frame-group.
Do not give panel%s or control<%>s this frame as parent. Instead, use the result of the get-area-container method.
This mixin also creates a menu bar for the frame, as the frame is initialized. It uses the class returned by get-menu-bar%. It only passes the frame as an initialization argument. In addition, it creates the windows menu in the menu bar.
See also frame:reorder-menus.
on? : boolean
Overrides show in top-level-window<%>.
Calls the super method.
When on? is #t, inserts the frame into the frame group and when it is #f, removes the frame from the group.
Overrides can-exit? in top-level-window<%>.
This, together with on-exit mimics exit:exit.
First, it calls exit:set-exiting with #t. Then, it calls exit:can-exit?. If it returns #t, so does this method. If it returns #f, this method calls exit:set-exiting with #f.
Overrides on-exit in top-level-window<%>.
Together with can-exit? this mimics the behavior of exit:exit.
Calls exit:on-exit and then queues a callback to call MzScheme’s exit function. If that returns, it calls exit:set-exiting to reset that flag to #f.
(send a-frame:basic on-superwindow-show shown?) → void
shown? : any/c
Overrides on-superwindow-show in window<%>.
Notifies the result of (group:get-the-frame-group) that a frame has been shown, by calling the frame-shown/hidden method.
(send a-frame:basic on-drop-file pathname) → void
pathname : string
Overrides on-drop-file in window<%>.
Calls handler:edit-file with pathname as an argument.
(send a-frame:basic after-new-child) → void
Overrides after-new-child in area-container<%>.
Raises an exception if attempting to add a child to this frame (except if using the make-root-area-container method).
|
frame:size-pref-mixin : (class? . -> . class?) | ||
| ||
|
[size-preferences-key size-preferences-key]
[label label]
[
[parent parent]
[x x]
[y y]
[style style]
[enabled enabled]
[border border]
[spacing spacing]
[alignment alignment]
[min-width min-width]
[min-height min-height]
[stretchable-width stretchable-width]
[stretchable-height stretchable-height]])
size-preferences-key : symbol?
label : label-string?
x : (or/c (integer-in -10000 10000) false/c) = #f
y : (or/c (integer-in -10000 10000) false/c) = #f
style
:
(listof (one-of/c 'no-resize-border 'no-caption 'no-system-menu 'hide-menu-bar 'mdi-parent 'mdi-child 'toolbar-button 'float 'metal))
=
enabled : any/c = #t
border : (integer-in 0 1000) = 0
spacing : (integer-in 0 1000) = 0
alignment
:
(list/c (one-of/c 'left 'center 'right) (one-of/c 'top 'center 'bottom))
=
'(center top)
min-width : (integer-in 0 10000) = graphical-minimum-width
min-height : (integer-in 0 10000) = graphical-minimum-height
stretchable-width : any/c = #t
stretchable-height : any/c = #t
The size size-preferences-key symbol is used with preferences:get and preferences:set to track the current size.
Passes the width and height initialization arguments to the superclass based on the current value of the preference.
See also frame:setup-size-pref.
width
height)
→
width : number
height : number
Overrides on-size in window<%>.
Updates the preferences, according to the width and height. The preferences key is the one passed to the initialization argument of the class.
Frames that implement this interface are registered with the group. See group:get-the-frame-group and frame:register-group-mixin.
frame:register-group-mixin : (class? . -> . class?) | ||
| ||
|
During initialization, calls insert-framewith this.
(send a-frame:register-group can-close?) → bool
Augments can-close? in top-level-window<%>.
Calls the inner method, with a default of #t. If that returns #t, it checks for one of the these three conditions:
exit:exiting? returns #t
there is more than one frame in the group returned by group:get-the-frame-group, or
the procedure exit:user-oks-exit returns #t.
If any of those conditions hold, the method returns #t.
Augments on-close in top-level-window<%>.
First calls the inner method. Next, calls the remove-frame method of the result of group:get-the-frame-group with this as an argument. Finally, unless exit:exiting? returns #t, and if there are no more frames open, it calls exit:exit.
(send a-frame:register-group on-activate on?) → void
on? : boolean
Overrides on-activate in top-level-window<%>.
Calls set-active-frame with this when on? is true.
|
The mixin that implements this interface provides an interface to a set of status lines at the bottom of this frame.
Each status line must be opened with open-status-line before any messages are shown in the status line and once close-status-line is called, no more messages may be displayed, unless the status line is re-opened.
The screen space for status lines is not created until update-status-line is called with a string. Additionally, the screen space for one status line is re-used when by another status line when the first passes #f to update-status-line. In this manner, the status line frame avoids opening too many status lines and avoids flashing the status lines open and closed too often.
(send a-frame:status-line open-status-line id) → void
id : symbol?
Creates a new status line identified by the symbol argument. The line will not appear in the frame until a message is put into it, via update-status-line.
(send a-frame:status-line close-status-line id) → void
id : symbol?
Closes the status line id.
(send a-frame:status-line update-status-line
id
status)
→
id : symbol?
status : (union |#f| string)
Updates the status line named by id with status. If status is #f, the status line is becomes blank (and may be used by other ids).
frame:status-line-mixin : (class? . -> . class?) | ||
| ||
|
(send a-frame:status-line make-root-area-container
class
parent)
class : (subclass?/c panel%)
parent : (instanceof (subclass?/c panel%))
Overrides make-root-area-container in frame:basic<%>.
Adds a panel at the bottom of the frame to hold the status lines.
|
Frames matching this interface support a status line.
The preference 'framework:show-status-line controls the visibility of the status line. If it is #t, the status line is visible and if it is #f, the status line is not visible (see preferences:get for more info about preferences)
(send a-frame:info determine-width
str
canvas
text)
→
integer
str : string
canvas : (instance editor-canvas%)
text : (instance text%)
This method is used to calculate the size of an editor-canvas% with a particular set of characters in it. It is used to calculate the sizes of the edits in the status line.
(send a-frame:info lock-status-changed) → void
This method is called when the lock status of the editor<%> changes.
Updates the lock icon in the status line panel.
(send a-frame:info update-info) → void
This method updates all of the information in the panel.
(send a-frame:info set-info-canvas canvas) → void
canvas : (instance canvas:basic%)
Sets this canvas to be the canvas that the info frame shows info about. The on-focus and set-editor methods call this method to ensure that the info canvas is set correctly.
(send a-frame:info get-info-canvas) → (instance canvas:basic%)
Returns the canvas that the frame:info<%> currently shows info about. See also set-info-canvas
(send a-frame:info get-info-editor)
Override this method to specify the editor that the status line contains information about.
Returns the result of get-editor.
(send a-frame:info get-info-panel)
→ (instance horizontal-panel%)
This method returns the panel where the information about this editor is displayed.
Shows the info panel.
See also is-info-hidden?.
Hides the info panel.
See also is-info-hidden?.
(send a-frame:info is-info-hidden?) → boolean
Result indicates if the show info panel has been explicitly hidden with hide-info.
If this method returns #t and (preferences:get 'framework:show-status-line) is #f, then the info panel will not be visible. Otherwise, it is visible.
frame:info-mixin : (class? . -> . class?) | ||
| ||
|
This mixin provides support for displaying various info in the status line of the frame.
The result of this mixin uses the same initialization arguments as the mixin’s argument.
(send a-frame:info make-root-area-container
class
parent)
→ (instance area-container<%>)
class : (subclass?/c area-container<%>)
parent : (is-a?/c area-container<%>)
Overrides make-root-area-container in frame:basic<%>.
Builds an extra panel for displaying various information.
Augments on-close in top-level-window<%>.
Removes the GC icon with unregister-collecting-blit and cleans up other callbacks.
|
Objects matching this interface receive information from editors constructed with editor:info-mixin and display it.
(send a-frame:text-info set-macro-recording on?) → void
on? : boolean
Shows/hides the icon in the info bar that indicates if a macro recording is in progress.
(send a-frame:text-info overwrite-status-changed) → void
This method is called when the overwrite mode is turned either on or off in the editor<%> in this frame.
(send a-frame:text-info anchor-status-changed) → void
This method is called when the anchor is turned either on or off in the editor<%> in this frame.
(send a-frame:text-info editor-position-changed) → void
This method is called when the position in the editor<%> changes.
frame:text-info-mixin : (class? . -> . class?) | ||
| ||
|
This mixin adds status information to the info panel relating to an edit.
Augments on-close in top-level-window<%>.
removes a preferences callback for 'framework:line-offsets. See preferences:add-callback for more information.
(send a-frame:text-info update-info) → void
Overrides update-info in frame:info<%>.
Calls overwrite-status-changed, anchor-status-changed, and editor-position-changed.
|
frame:pasteboard-info-mixin : (class? . -> . class?) | ||
| ||
|
|
file-menu:new-callback, file-menu:create-new?, file-menu:new-string, file-menu:new-help-string, file-menu:new-on-demand, file-menu:get-new-item
file-menu:open-callback, file-menu:create-open?, file-menu:open-string, file-menu:open-help-string, file-menu:open-on-demand, file-menu:get-open-item
file-menu:open-recent-callback, file-menu:create-open-recent?, file-menu:open-recent-string, file-menu:open-recent-help-string, file-menu:open-recent-on-demand, file-menu:get-open-recent-item
file-menu:revert-callback, file-menu:create-revert?, file-menu:revert-string, file-menu:revert-help-string, file-menu:revert-on-demand, file-menu:get-revert-item
file-menu:save-callback, file-menu:create-save?, file-menu:save-string, file-menu:save-help-string, file-menu:save-on-demand, file-menu:get-save-item
file-menu:save-as-callback, file-menu:create-save-as?, file-menu:save-as-string, file-menu:save-as-help-string, file-menu:save-as-on-demand, file-menu:get-save-as-item
file-menu:print-callback, file-menu:create-print?, file-menu:print-string, file-menu:print-help-string, file-menu:print-on-demand, file-menu:get-print-item
file-menu:close-callback, file-menu:create-close?, file-menu:close-string, file-menu:close-help-string, file-menu:close-on-demand, file-menu:get-close-item
file-menu:quit-callback, file-menu:create-quit?, file-menu:quit-string, file-menu:quit-help-string, file-menu:quit-on-demand, file-menu:get-quit-item
edit-menu:undo-callback, edit-menu:create-undo?, edit-menu:undo-string, edit-menu:undo-help-string, edit-menu:undo-on-demand, edit-menu:get-undo-item
edit-menu:redo-callback, edit-menu:create-redo?, edit-menu:redo-string, edit-menu:redo-help-string, edit-menu:redo-on-demand, edit-menu:get-redo-item
edit-menu:cut-callback, edit-menu:create-cut?, edit-menu:cut-string, edit-menu:cut-help-string, edit-menu:cut-on-demand, edit-menu:get-cut-item
edit-menu:copy-callback, edit-menu:create-copy?, edit-menu:copy-string, edit-menu:copy-help-string, edit-menu:copy-on-demand, edit-menu:get-copy-item
edit-menu:paste-callback, edit-menu:create-paste?, edit-menu:paste-string, edit-menu:paste-help-string, edit-menu:paste-on-demand, edit-menu:get-paste-item
edit-menu:clear-callback, edit-menu:create-clear?, edit-menu:clear-string, edit-menu:clear-help-string, edit-menu:clear-on-demand, edit-menu:get-clear-item
edit-menu:select-all-callback, edit-menu:create-select-all?, edit-menu:select-all-string, edit-menu:select-all-help-string, edit-menu:select-all-on-demand, edit-menu:get-select-all-item
edit-menu:find-callback, edit-menu:create-find?, edit-menu:find-string, edit-menu:find-help-string, edit-menu:find-on-demand, edit-menu:get-find-item
edit-menu:find-again-callback, edit-menu:create-find-again?, edit-menu:find-again-string, edit-menu:find-again-help-string, edit-menu:find-again-on-demand, edit-menu:get-find-again-item
edit-menu:replace-and-find-again-callback, edit-menu:create-replace-and-find-again?, edit-menu:replace-and-find-again-string, edit-menu:replace-and-find-again-help-string, edit-menu:replace-and-find-again-on-demand, edit-menu:get-replace-and-find-again-item
edit-menu:preferences-callback, edit-menu:create-preferences?, edit-menu:preferences-string, edit-menu:preferences-help-string, edit-menu:preferences-on-demand, edit-menu:get-preferences-item
help-menu:about-callback, help-menu:create-about?, help-menu:about-string, help-menu:about-help-string, help-menu:about-on-demand, help-menu:get-about-item
The result of this method is used as the class for creating the result of these methods: get-file-menu, get-edit-menu, get-help-menu.
defaultly returns menu%
(send a-frame:standard-menus get-menu-item%)
The result of this method is used as the class for creating the menu items in this frame (see frame:standard-menus% for a list).
defaultly returns menu:can-restore-menu-item%.
(send a-frame:standard-menus get-checkable-menu-item%)
The result of this method is used as the class for creating checkable menu items in this class (see frame:standard-menus% for a list).
defaultly returns menu:can-restore-checkable-menu-item%.
(send a-frame:standard-menus get-file-menu)
→ (instance (subclass?/c menu%))
Returns the file menu See also get-menu%
(send a-frame:standard-menus get-edit-menu)
→ (instance (subclass?/c menu%))
Returns the edit menu See also get-menu%
(send a-frame:standard-menus get-help-menu)
→ (instance (subclass?/c menu%))
Returns the help menu See also get-menu%
(send a-frame:standard-menus file-menu:new-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the new menu-item of the file-menu menu is selected.
Defaultly bound to:
(λ (item control) (handler:edit-file #f) #t)
(send a-frame:standard-menus file-menu:get-new-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:new-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant new-menu-item)"
(send a-frame:standard-menus file-menu:new-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant new-info).
(send a-frame:standard-menus file-menu:new-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-new?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus file-menu:between-new-and-open menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the new menu-item and before the addition of the open menu-item to the file-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus file-menu:open-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the open menu-item of the file-menu menu is selected.
Defaultly bound to:
(λ (item control) (handler:open-file) #t)
(send a-frame:standard-menus file-menu:get-open-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:open-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant open-menu-item)"
(send a-frame:standard-menus file-menu:open-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant open-info)
(send a-frame:standard-menus file-menu:open-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-open?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus file-menu:open-recent-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the open-recent menu-item of the file-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus file-menu:get-open-recent-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:open-recent-string)
→ string
The result of this method is the name of this menu.
defaultly returns "(string-constant open-recent-menu-item)"
(send a-frame:standard-menus file-menu:open-recent-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant open-recent-info)
(send a-frame:standard-menus file-menu:open-recent-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu) (handler:install-recent-items menu))
(send a-frame:standard-menus file-menu:create-open-recent?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus file-menu:between-open-and-revert menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the open menu-item and before the addition of the revert menu-item to the file-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus file-menu:revert-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the revert menu-item of the file-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus file-menu:get-revert-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:revert-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant revert-menu-item)"
(send a-frame:standard-menus file-menu:revert-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant revert-info)
(send a-frame:standard-menus file-menu:revert-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-revert?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus file-menu:between-revert-and-save menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the revert menu-item and before the addition of the save menu-item to the file-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus file-menu:save-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the save menu-item of the file-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus file-menu:get-save-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:save-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant save-menu-item)"
(send a-frame:standard-menus file-menu:save-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant save-info)
(send a-frame:standard-menus file-menu:save-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-save?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus file-menu:save-as-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the save-as menu-item of the file-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus file-menu:get-save-as-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:save-as-string)
→ string
The result of this method is the name of this menu.
defaultly returns "(string-constant save-as-menu-item)"
(send a-frame:standard-menus file-menu:save-as-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant save-as-info)
(send a-frame:standard-menus file-menu:save-as-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-save-as?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus file-menu:between-save-as-and-print menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the save-as menu-item and before the addition of the print menu-item to the file-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus file-menu:print-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the print menu-item of the file-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus file-menu:get-print-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:print-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant print-menu-item)"
(send a-frame:standard-menus file-menu:print-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant print-info)
(send a-frame:standard-menus file-menu:print-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-print?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus file-menu:between-print-and-close menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the print menu-item and before the addition of the close menu-item to the file-menu menu. Override it to add additional menus at that point.
Adds a separator menu item.
(send a-frame:standard-menus file-menu:close-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the close menu-item of the file-menu menu is selected.
Defaultly bound to:
(λ (item control) (when (can-close?) (on-close) (show #f)) #t)
(send a-frame:standard-menus file-menu:get-close-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:close-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant close-menu-item)"
(send a-frame:standard-menus file-menu:close-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant close-info)
(send a-frame:standard-menus file-menu:close-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-close?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus file-menu:between-close-and-quit menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the close menu-item and before the addition of the quit menu-item to the file-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus file-menu:quit-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the quit menu-item of the file-menu menu is selected.
Defaultly bound to:
(λ (item control) (when (exit:user-oks-exit) (exit:exit)))
(send a-frame:standard-menus file-menu:get-quit-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus file-menu:quit-string) → string
The result of this method is the name of this menu.
defaultly returns "(if (eq? (system-type) (quote windows)) (string-constant quit-menu-item-windows) (string-constant quit-menu-item-others))"
(send a-frame:standard-menus file-menu:quit-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant quit-info)
(send a-frame:standard-menus file-menu:quit-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus file-menu:create-quit?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns (not (current-eventspace-has-standard-menus?))
(send a-frame:standard-menus file-menu:after-quit menu) → void
menu : (instance (subclass?/c menu%))
This method is called after the addition of the quit menu-item to the file-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus edit-menu:undo-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the undo menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'undo)))
#t)
(send a-frame:standard-menus edit-menu:get-undo-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:undo-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant undo-menu-item)"
(send a-frame:standard-menus edit-menu:undo-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant undo-info)
(send a-frame:standard-menus edit-menu:undo-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'undo)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-undo?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:redo-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the redo menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'redo)))
#t)
(send a-frame:standard-menus edit-menu:get-redo-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:redo-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant redo-menu-item)"
(send a-frame:standard-menus edit-menu:redo-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant redo-info)
(send a-frame:standard-menus edit-menu:redo-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'redo)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-redo?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:between-redo-and-cut menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the redo menu-item and before the addition of the cut menu-item to the edit-menu menu. Override it to add additional menus at that point.
Adds a separator menu item.
(send a-frame:standard-menus edit-menu:cut-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the cut menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'cut)))
#t)
(send a-frame:standard-menus edit-menu:get-cut-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:cut-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant cut-menu-item)"
(send a-frame:standard-menus edit-menu:cut-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant cut-info)
(send a-frame:standard-menus edit-menu:cut-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'cut)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-cut?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:between-cut-and-copy menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the cut menu-item and before the addition of the copy menu-item to the edit-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus edit-menu:copy-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the copy menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'copy)))
#t)
(send a-frame:standard-menus edit-menu:get-copy-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:copy-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant copy-menu-item)"
(send a-frame:standard-menus edit-menu:copy-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant copy-info)
(send a-frame:standard-menus edit-menu:copy-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'copy)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-copy?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:between-copy-and-paste menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the copy menu-item and before the addition of the paste menu-item to the edit-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus edit-menu:paste-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the paste menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'paste)))
#t)
(send a-frame:standard-menus edit-menu:get-paste-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:paste-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant paste-menu-item)"
(send a-frame:standard-menus edit-menu:paste-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant paste-info)
(send a-frame:standard-menus edit-menu:paste-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'paste)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-paste?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:between-paste-and-clear menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the paste menu-item and before the addition of the clear menu-item to the edit-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus edit-menu:clear-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the clear menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'clear)))
#t)
(send a-frame:standard-menus edit-menu:get-clear-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:clear-string) → string
The result of this method is the name of this menu.
defaultly returns "(if (eq? (system-type) (quote windows)) (string-constant clear-menu-item-windows) (string-constant clear-menu-item-windows))"
(send a-frame:standard-menus edit-menu:clear-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant clear-info)
(send a-frame:standard-menus edit-menu:clear-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'clear)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-clear?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:between-clear-and-select-all menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the clear menu-item and before the addition of the select-all menu-item to the edit-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus edit-menu:select-all-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the select-all menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (menu evt)
(let ((edit (get-edit-target-object)))
(send edit do-edit-operation 'select-all)))
#t)
(send a-frame:standard-menus edit-menu:get-select-all-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:select-all-string)
→ string
The result of this method is the name of this menu.
defaultly returns "(string-constant select-all-menu-item)"
(send a-frame:standard-menus edit-menu:select-all-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant select-all-info)
(send a-frame:standard-menus edit-menu:select-all-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (let* ((editor (get-edit-target-object)) (enable? (and editor (is-a? editor editor<%>) (send editor can-do-edit-operation? 'select-all)))) (send item enable enable?)))
(send a-frame:standard-menus edit-menu:create-select-all?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #t
(send a-frame:standard-menus edit-menu:between-select-all-and-find menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the select-all menu-item and before the addition of the find menu-item to the edit-menu menu. Override it to add additional menus at that point.
Adds a separator menu item.
(send a-frame:standard-menus edit-menu:find-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the find menu-item of the edit-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus edit-menu:get-find-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:find-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant find-menu-item)"
(send a-frame:standard-menus edit-menu:find-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant find-info)
(send a-frame:standard-menus edit-menu:find-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (send item enable (let ((target (get-edit-target-object))) (and target (is-a? target editor<%>)))))
(send a-frame:standard-menus edit-menu:create-find?) → boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus edit-menu:find-again-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the find-again menu-item of the edit-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus edit-menu:get-find-again-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:find-again-string)
→ string
The result of this method is the name of this menu.
defaultly returns "(string-constant find-again-menu-item)"
(send a-frame:standard-menus edit-menu:find-again-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant find-again-info)
(send a-frame:standard-menus edit-menu:find-again-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (send item enable (let ((target (get-edit-target-object))) (and target (is-a? target editor<%>)))))
(send a-frame:standard-menus edit-menu:create-find-again?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus edit-menu:replace-and-find-again-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the replace-and-find-again menu-item of the edit-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus edit-menu:get-replace-and-find-again-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:replace-and-find-again-string)
→ string
The result of this method is the name of this menu.
defaultly returns "(string-constant replace-and-find-again-menu-item)"
(send a-frame:standard-menus edit-menu:replace-and-find-again-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant replace-and-find-again-info)
(send a-frame:standard-menus edit-menu:replace-and-find-again-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (item) (send item enable (let ((target (get-edit-target-object))) (and target (is-a? target editor<%>)))))
(send a-frame:standard-menus edit-menu:create-replace-and-find-again?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus edit-menu:between-find-and-preferences menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called between the addition of the find menu-item and before the addition of the preferences menu-item to the edit-menu menu. Override it to add additional menus at that point.
Adds a separator except when current-eventspace-has-standard-menus? returns #t.
(send a-frame:standard-menus edit-menu:preferences-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the preferences menu-item of the edit-menu menu is selected.
Defaultly bound to:
(λ (item control) (preferences:show-dialog) #t)
(send a-frame:standard-menus edit-menu:get-preferences-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus edit-menu:preferences-string)
→ string
The result of this method is the name of this menu.
defaultly returns "(string-constant preferences-menu-item)"
(send a-frame:standard-menus edit-menu:preferences-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant preferences-info)
(send a-frame:standard-menus edit-menu:preferences-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus edit-menu:create-preferences?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns (not (current-eventspace-has-standard-menus?))
(send a-frame:standard-menus edit-menu:after-preferences menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called after the addition of the preferences menu-item to the edit-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus help-menu:before-about menu)
→ void
menu : (instance (subclass?/c menu%))
This method is called before the addition of the about menu-item to the help-menu menu. Override it to add additional menus at that point.
Does nothing.
(send a-frame:standard-menus help-menu:about-callback
item
evt)
→ void
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
This method is called when the about menu-item of the help-menu menu is selected.
Defaultly bound to:
(send a-frame:standard-menus help-menu:get-about-item)
→ (instance menu-item%)
This method returns the menu-item% that corresponds to this menu item.
(send a-frame:standard-menus help-menu:about-string) → string
The result of this method is the name of this menu.
defaultly returns "(string-constant about-menu-item)"
(send a-frame:standard-menus help-menu:about-help-string)
→ string
This result of this method is used as the help string when the menu-item% object is created.
Defaultly returns (string-constant about-info)
(send a-frame:standard-menus help-menu:about-on-demand item)
→ void
item : menu-item%
The menu item’s on-demand method calls this method
Defaultly is this: (λ (menu-item) (void))
(send a-frame:standard-menus help-menu:create-about?)
→ boolean
The result of this method determines if the corresponding menu-item is created. Override this to control the creation of the menu-item.
defaultly returns #f
(send a-frame:standard-menus help-menu:after-about menu) → void
menu : (instance (subclass?/c menu%))
This method is called after the addition of the about menu-item to the help-menu menu. Override it to add additional menus at that point.
Does nothing.
frame:standard-menus-mixin : (class? . -> . class?) | ||
| ||
|
The result of this mixin implements frame:standard-menus<%>.
Augments on-close in top-level-window<%>.
Removes the preferences callbacks for the menu items
|
Frame classes matching this interface support embedded editors.
(send a-frame:editor get-entire-label) → string
This method returns the entire label for the frame. See also set-label and set-label-prefix.
(send a-frame:editor get-label-prefix) → string
This returns the prefix for the frame’s label.
(send a-frame:editor set-label-prefix prefix) → void
prefix : string
Sets the prefix for the label of the frame.
(send a-frame:editor get-canvas%)
The result of this method is used to create the canvas for the editor<%> in this frame.
Returns editor-canvas%.
(send a-frame:editor get-canvas<%>) → (instance canvas:basic%)
The result of this method is used to guard the result of the get-canvas% method.
(send a-frame:editor get-editor%) → (is-a?/c editor<%>)
The result of this class is used to create the editor<%> in this frame.
Override this method to specify a different editor class.
Returns the value of the init-field editor%.
(send a-frame:editor get-editor<%>) → interface
The result of this method is used by make-editor to check that get-editor% is returning a reasonable editor.
Returns editor<%>.
(send a-frame:editor make-editor)
This method is called to create the editor in this frame. It calls get-editor<%> and uses that interface to make sure the result of get-editor% is reasonable.
Calls (make-object (method frame:editor<%> get-editor%)).
Loads the most recently saved version of the file to the disk. If the editor<%> is a text%, the start and end positions are restored.
format
:
(union 'guess 'standard 'text 'text-force-cr 'same 'copy)
=
'same
Saves the file being edited, possibly calling save-as if the editor has no filename yet.
Returns #f if the user cancels this operation (only possible when the file has not been saved before and the user is prompted for a new filename) and returns #t if not.
format
:
(union 'guess 'standard 'text 'text-force-cr 'same 'copy)
=
'same
Queries the use for a file name and saves the file with that name.
Returns #f if the user cancells the file-choosing dialog and returns #t otherwise.
(send a-frame:editor get-canvas)
→ (instance (subclass?/c canvas%))
Returns the canvas used to display the editor<%> in this frame.
(send a-frame:editor get-editor)
Returns the editor in this frame.
frame:editor-mixin : (class? . -> . class?) | ||
| ||
|
This mixin adds functionality to support an editor<%> in the frame. This includes management of the title, implementations of some of the menu items, a reasonable initial size, and access to the editor<%> itself.
The size of this frame with be either 600 by 650 or 65 less than the width and height of the screen, whichever is smaller.
[filename filename]
[editor% editor%]
[
[parent parent]
[width width]
[height height]
[x x]
[y y]
[style style]
[enabled enabled]
[border border]
[spacing spacing]
[alignment alignment]
[min-width min-width]
[min-height min-height]
[stretchable-width stretchable-width]
[stretchable-height stretchable-height]])
filename : string?
width : (or/c (integer-in 0 10000) false/c) = #f
height : (or/c (integer-in 0 10000) false/c) = #f
x : (or/c (integer-in -10000 10000) false/c) = #f
y : (or/c (integer-in -10000 10000) false/c) = #f
style
:
(listof (one-of/c 'no-resize-border 'no-caption 'no-system-menu 'hide-menu-bar 'mdi-parent 'mdi-child 'toolbar-button 'float 'metal))
=
enabled : any/c = #t
border : (integer-in 0 1000) = 0
spacing : (integer-in 0 1000) = 0
alignment
:
(list/c (one-of/c 'left 'center 'right) (one-of/c 'top 'center 'bottom))
=
'(center top)
min-width : (integer-in 0 10000) = graphical-minimum-width
min-height : (integer-in 0 10000) = graphical-minimum-height
stretchable-width : any/c = #t
stretchable-height : any/c = #t
(send a-frame:editor get-filename) → (union |#f| path)
Overrides get-filename in frame:basic<%>.
Returns the filename in the editor returned by get-editor.
(send a-frame:editor editing-this-file? filename) → boolean
filename : path
Overrides editing-this-file? in frame:basic<%>.
Returns #t if the filename is the file that this frame is editing.
Augments on-close in top-level-window<%>.
Calls the editor:basic<%>’s method on-close.
(send a-frame:editor can-close?) → void
Augments can-close? in top-level-window<%>.
Calls the editor:basic<%>’s method can-close?.
Overrides get-label in window<%>.
Returns the portion of the label after the hyphen. See also get-entire-label.
label : string?
Overrides set-label in window<%>.
Sets the label, but preserves the label’s prefix. See also set-label-prefix.
(send a-frame:editor file-menu:open-callback
item
evt)
→
item : any
evt : mouse-event
Overrides file-menu:open-callback in frame:standard-menus<%>.
Calls handler:open-file with the directory of the saved file associated with this editor (if any).
(send a-frame:editor file-menu:revert-on-demand) → void
Overrides file-menu:revert-on-demand in frame:standard-menus<%>.
Disables the menu item when the editor is locked.
(send a-frame:editor file-menu:revert-callback
item
evt)
→
item : (is-a?/c menu-item%)
evt : (is-a?/c control-event%)
Overrides file-menu:revert-callback in frame:standard-menus<%>.
Informs the user that this action is not undoable and, if they still want to continue, calls revert.
(send a-frame:editor file-menu:create-revert?) → boolean
Overrides file-menu:create-revert? in frame:standard-menus<%>.
returns #t
(send a-frame:editor file-menu:save-callback
item
evt)
→
item : (is-a?/c menu-item%)
evt : (is-a?/c control-event%)
Overrides file-menu:save-callback in frame:standard-menus<%>.
Saves the file in the editor.
(send a-frame:editor file-menu:create-save?) → boolean
Overrides file-menu:create-save? in frame:standard-menus<%>.
returns #t
(send a-frame:editor file-menu:save-as-callback
item
evt)
→
item : (is-a?/c menu-item%)
evt : (is-a?/c control-event%)
Overrides file-menu:save-as-callback in frame:standard-menus<%>.
Prompts the user for a file name and uses that filename to save the buffer. Calls save-as with no arguments.
(send a-frame:editor file-menu:create-save-as?) → boolean
Overrides file-menu:create-save-as? in frame:standard-menus<%>.
returns #t
(send a-frame:editor file-menu:print-callback
item
evt)
→
item : (is-a?/c menu-item%)
evt : (is-a?/c control-event%)
Overrides file-menu:print-callback in frame:standard-menus<%>.
Calls the print method of editor<%> with the default arguments, except that the output-mode argument is the result of calling preferences:get with 'framework:print-output-mode.
(send a-frame:editor file-menu:create-print?) → boolean
Overrides file-menu:create-print? in frame:standard-menus<%>.
returns #t
(send a-frame:editor file-menu:between-save-as-and-print file-menu)
→ void
Overrides file-menu:between-save-as-and-print in frame:standard-menus<%>.
Creates a Print Setup menu item.
(send a-frame:editor edit-menu:between-select-all-and-find edit-menu)
→ void
edit-menu : (instance menu%)
Overrides edit-menu:between-select-all-and-find in frame:standard-menus<%>.
Adds a menu item for toggling auto-wrap in the focused text.
(send a-frame:editor help-menu:about-callback
item
evt)
→
item : (is-a?/c menu-item%)
evt : (is-a?/c control-event%)
Overrides help-menu:about-callback in frame:standard-menus<%>.
Calls message-box with a message welcoming the user to the application named by application:current-app-name
(send a-frame:editor help-menu:about-string) → string
Overrides help-menu:about-string in frame:standard-menus<%>.
Returns the result of (application:current-app-name)
(send a-frame:editor help-menu:create-about?) → boolean
Overrides help-menu:create-about? in frame:standard-menus<%>.
returns #t
|
Frames implementing this mixin can change the file they are displaying.
The frame is only re-used when the 'framework:open-here? preference is set (see preferences:get and preferences:set for details on preferences).
The frame:open-here-mixin implements this interface.
(send a-frame:open-here get-open-here-editor)
When the user switches the visible file in this frame, the of this method is the editor that gets switched.
Defaultly returns the result of get-editor.
filename : string
Opens filename in the current frame, possibly prompting the user about saving a file (in which case the frame might not get switched).
frame:open-here-mixin : (class? . -> . class?) | ||
| ||
|
Provides an implementation of frame:open-here<%>
(send a-frame:open-here file-menu:new-on-demand item) → void
item : (is-a?/c menu-item%)
Overrides file-menu:new-on-demand in frame:standard-menus<%>.
Sets the label of item to "New..." if the preference 'framework:open-here? is set.
(send a-frame:open-here file-menu:new-callback
item
evt)
→
item : (instance (subclass?/c menu-item%))
evt : (instance control-event%)
Overrides file-menu:new-callback in frame:standard-menus<%>.
When the preference 'framework:open-here? preference is set, this method prompts the user, asking if they would like to create a new frame, or just clear out this one. If they clear it out and the file hasn’t been saved, they are asked about saving.
(send a-frame:open-here file-menu:open-on-demand item) → void
item : (is-a?/c menu-item%)
Overrides file-menu:open-on-demand in frame:standard-menus<%>.
Sets the label of item to "Open Here..." if the preference 'framework:open-here? is set.
Augments on-close in top-level-window<%>.
Calls set-open-here-frame with #f if the result of get-open-here-frame is eq? to this.
(send a-frame:open-here on-activate on?) → void
on? : boolean
Overrides on-activate in top-level-window<%>.
When on? is #t, calls set-open-here-frame with this.
|
Frames matching this interface provide support for text%s.
frame:text-mixin : (class? . -> . class?) | ||
| ||
|
This mixins adds support for text%s in the frame.
(new frame:text-mixin [editor% editor%])
Calls the super initialization with either the value of the editor% init or, if none was supplied, it passes text%.
(send a-frame:text get-editor<%>) → interface
Overrides get-editor<%> in frame:editor<%>.
Returns (class->interface (scheme text%)).
|
Frames matching this interface provide support for pasteboard%s.
frame:pasteboard-mixin : (class? . -> . class?) | ||
| ||
|
This mixin provides support for pasteboards in a frame.
(new frame:pasteboard-mixin [editor% editor%])
editor% : (extends pasteboard%)
Calls the super initialization with either the value of the editor% init or, if none was supplied, it passes pasteboard%.
(send a-frame:pasteboard get-editor<%>) → interface
Overrides get-editor<%> in frame:editor<%>.
Returns (class->interface (scheme pasteboard%)).
|
Frames that implement this interface provide a 20,000 feet overview of the text in the main editor. The term delegate in these method descriptions refers to the original editor and the term delegatee refers to the editor showing the 20,000 feet overview.
(send a-frame:delegate get-delegated-text)
→ (instanceof (is-a?/c text:delegate<%>))
Returns the delegate text.
(send a-frame:delegate delegated-text-shown?) → boolean
Returns #t if the delegate is visible, and #f if it isn’t.
(send a-frame:delegate hide-delegated-text) → void
Hides the delegated text.
When the delegated text is hidden, it is not being updated. This is accomplished by calling the set-delegate method of get-editorwith #f.
See also show-delegated-text
(send a-frame:delegate show-delegated-text) → void
Makes the delegated text visible.
When the delegated text is shown, the set-delegate method of get-delegated-textis called with the text to delegate messages to.
See also hide-delegated-text.
(send a-frame:delegate delegate-moved) → void
This method is called when the visible region of the delegate editor changes, so that the blue region in the delegatee is updated.
frame:delegate-mixin : (class? . -> . class?) | ||||
| ||||
|
Adds support for a 20,000-feet view via text:delegate<%> and text:delegate-mixin
(send a-frame:delegate make-root-area-container
class
parent)
class : (subclass?/c panel%)
parent : (instanceof (subclass?/c panel%))
Overrides make-root-area-container in frame:basic<%>.
adds a panel outside to hold the delegate editor-canvas% and text%.
(send a-frame:delegate get-editor<%>) → interface
Overrides get-editor<%> in frame:editor<%>.
Returns text:delegate.
(send a-frame:delegate get-editor%)
Overrides get-editor% in frame:editor<%>.
returns the super result, with the text:delegate-mixin mixed in.
|
Frames that implement this interface support searching.
(send a-frame:searchable get-text-to-search)
→ (instance (subclass?/c text%))
Override this method to specify which text to search.
Returns the result of get-editor.
(send a-frame:searchable hide-search) → void
This method hides the searching information on the bottom of the frame.
(send a-frame:searchable unhide-search) → void
When the searching sub window is hidden, makes it visible.
(send a-frame:searchable set-search-direction dir) → void
dir : (union -1 1)
Sets the direction that future searches will be performed.
If dir is 1 searches will be performed forwards and if dir is -1 searches will be performed backwards.
(send a-frame:searchable replace&search) → boolean
Calls replace and if it returns #t, calls search-again.
(send a-frame:searchable replace-all) → void
Loops through the text from the current position to the end, replacing all occurrences of the search string with the contents of the replace edit. Only searches forward, does not loop around to the beginning of the text.
If the selected text matches the search string, this method replaces the text with the contents of the replace text. If the replace was successful, #t is returned. Otherwise, #f is returned.
(send a-frame:searchable can-replace?) → boolean
Returns #t if a replace command would succeed.
Defaultly is #t when the selected text in the result of get-text-to-search is the same as the text in the find text.
(send a-frame:searchable toggle-search-focus) → void
Toggles the keyboard focus between the searching edit, the replacing edit and the result of get-text-to-search.
(send a-frame:searchable move-to-search-or-search)
→ (union boolean void)
This method moves the focus to the text that contains the search string, or if the focus is there already, performs a forward search.
It returns void if the focus was not to the search text, otherwise it returns a boolean indicating the success of the search.
(send a-frame:searchable move-to-search-or-reverse-search)
→ (union boolean void)
This method moves the focus to the text that contains the search string, or if the focus is there already, performs a reverse search.
It returns void if the focus was not to the search text, otherwise it returns a boolean indicating the success of the search.
(send a-frame:searchable search-again
[
direction
beep?])
→
boolean
direction : Symbol = (rm previous searching direction)
beep? : bool = |#t|
Searches for the text in the search edit in the result of get-text-to-search.
Returns #t if the text is found and sets the selection to the found text. If the text is not found it returns #f.
frame:searchable-mixin : (class? . -> . class?) | ||
| ||
|
This mixin adds support for searching in the editor<%> in this frame.
The result of this mixin uses the same initialization arguments as the mixin’s argument.
(send a-frame:searchable edit-menu:find-callback
item
evt)
→
item : (is-a?/c menu-item%)
evt : (is-a?/c control-event%)
Overrides edit-menu:find-callback in frame:standard-menus<%>.
Calls move-to-search-or-search.
(send a-frame:searchable edit-menu:create-find?) → boolean
Overrides edit-menu:create-find? in frame:standard-menus<%>.
returns #t
(send a-frame:searchable edit-menu:find-again-callback)
→ boolean
Overrides edit-menu:find-again-callback in frame:standard-menus<%>.
Returns #t, and searches for the same text that was last searched for in the text.
(send a-frame:searchable edit-menu:create-find-again?)
→ boolean
Overrides edit-menu:create-find-again? in frame:standard-menus<%>.
returns #t
(send a-frame:searchable edit-menu:replace-and-find-again-callback)
→ boolean
Overrides edit-menu:replace-and-find-again-callback in frame:standard-menus<%>.
Returns #t, and if the selected text matches the current text in the find box, replaces it with the contents of the replace box and searches for the next occurrence of the text in the find box.
(send a-frame:searchable edit-menu:replace-and-find-again-on-demand item)
→ void
item : menu-item%
Overrides edit-menu:replace-and-find-again-on-demand in frame:standard-menus<%>.
Disables item when can-replace? returns #f and enables it when that method returns #t.
(send a-frame:searchable edit-menu:create-replace-and-find-again?)
→ boolean
Overrides edit-menu:create-replace-and-find-again? in frame:standard-menus<%>.
returns #t
(send a-frame:searchable make-root-area-container)
Overrides make-root-area-container in frame:basic<%>.
Builds a panel for the searching information.
(send a-frame:searchable on-activate) → void
Overrides on-activate in top-level-window<%>.
When the frame is activated, searches will take place in this frame.
Augments on-close in top-level-window<%>.
Cleans up after the searching frame.
|
frame:searchable-text-mixin : (class? . -> . class?) | ||||
| ||||
|
(send a-frame:searchable-text get-text-to-search)
→ (instanceof text%)
Overrides get-text-to-search in frame:searchable<%>.
Returns the result of get-editor.
(send a-frame:searchable-text get-editor<%>)
Overrides get-editor<%> in frame:editor<%>.
Returns text:searching<%>.
(send a-frame:searchable-text get-editor%)
Overrides get-editor% in frame:editor<%>.
Returns text:searching%.
superclass: (frame:register-group-mixin (frame:basic-mixin frame%)) |
superclass: (frame:size-pref-mixin frame:basic%) |
superclass: (frame:info-mixin frame:basic%) |
superclass: (frame:text-info-mixin frame:info%) |
superclass: (frame:pasteboard-info-mixin frame:text-info%) |
superclass: (frame:status-line-mixin frame:text-info%) |
superclass: (frame:standard-menus-mixin frame:status-line%) |
superclass: (frame:editor-mixin frame:standard-menus%) |
superclass: (frame:open-here-mixin frame:editor%) |
superclass: (frame:text-mixin frame:open-here%) |
superclass: (frame:searchable-text-mixin (frame:searchable-mixin frame:text%)) |
superclass: (frame:delegate-mixin frame:searchable%) |
superclass: (frame:pasteboard-mixin frame:open-here%) |
| |||||||||||||||||||||
size-pref-sym : symbol? | |||||||||||||||||||||
width : number? | |||||||||||||||||||||
height : number? |
Initializes a preference for the 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.
| |||||||||||||||||||||
menu-item% : (subclass?/c menu-item%) | |||||||||||||||||||||
Inserts three menu items into 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 menu-item% as the class for the menu items.
Calls func right after inserting each menu item.
(frame:reorder-menus frame) → void? |
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.
(frame:remove-empty-menus frame) → void? |
Removes empty menus in a frame.