diff --git a/collects/graphics/scribblings/turtles.scrbl b/collects/graphics/scribblings/turtles.scrbl index c74aa6890f..a30bf5e61d 100644 --- a/collects/graphics/scribblings/turtles.scrbl +++ b/collects/graphics/scribblings/turtles.scrbl @@ -1,7 +1,7 @@ #lang scribble/doc @(require scribble/manual) -@title{Turtle Graphics} +@title{@bold{Turtle Graphics}} Turtle graphics are available in two forms: traditional imperative turtle operations that draw into a fixed window, and functional turtle diff --git a/collects/hierlist/doc.txt b/collects/hierlist/doc.txt deleted file mode 100644 index da0a04ae67..0000000000 --- a/collects/hierlist/doc.txt +++ /dev/null @@ -1,229 +0,0 @@ - -_Hierarchical List Control_ - -hierlist.ss provides the classes and interfaces described below. -hierlist-sig.ss provides hierlist^, which includes the same classes and interfaces. -hierlist-unit.ss provide a unit that imports mred^ and exports hierlist^. - --------------------------------------------------- - -> hierarchical-list%, derived from editor-canvas% - -It accepts two initialization arguments. The first -specifies the GUI parent for the control and is -required. The second is the `style' parameter -passed to the super class (editor-canvas%) -and defaults to: '(no-hscroll). - - -New methods: - -> get-selected :: (send a-list get-selected) - returns #f or an - instance of hierarchical-list-item<%> - -> new-item :: (send a-list new-item) - creates and returns a new - (empty) hierarchical-list-item<%> - -> new-item :: (send a-list new-item mixin) - creates and returns - a new (empty) hierarchical-list-item<%>, but first, applies - `mixin' to a class implementing hierarchical-list-item<%> and uses - the result as the class for the new hierarchical-list-item<%> - object. - -> set-no-sublists :: (send a-list set-no-sublists no-sublists?) - - avoids space to the left of the list that would normally align - non-list items with list items; this method can be called only - when the list is empty - -> new-list :: (send a-list new-list) - creates and returns a new - (empty) hierarchical-list-compound-item<%> - -> new-list :: (send a-list new-list mixin) - creates and returns - a new (empty) hierarchical-list-compound-item<%>, but first, - applies `mixin' to a class implementing - hierarchical-list-compound-item<%> and uses the result as the - class for the new hierarchical-list-compound-item<%> object. - -> delete-item :: (send a-list delete-item i) - delete - hierarchical-list-item<%> i from the list - -> get-items :: (send a-list get-items) - returns a list of the items - in the list - -> selectable :: (send a-list selectable) - returns #t if items are - selectable, #f otherwise; default is #t -> selectable :: (send a-list selectable on?) - sets whether items - are selectable - -> on-select :: (send a-list on-select i) - called for new select of - `i', hierarchical-list-item<%> or #f, where #f means that no item - is selected - -> on-click :: (send a-list on-click i) - called when an item is - clicked on, but selection for that item is not allowed. - `i' is a hierarchical-list-item<%>. - - selection can be disallowed by the `set-allow-selection' method - or by the `selectable' method. - -> on-double-select :: (send a-list on-double-select i) - called for - double-click on hierarchical-list-item<%> `i' - -> on-item-opened :: (send a-list on-item-opened i) - called when the - arrow for `i' is turned down - -> on-item-closed :: (send a-list on-item-closed i) - called when the - arrow for `i' is turned up - -> sort :: (send a-list sort less-than-proc [recur?]) - sorts items in - the list by calling `less-than-proc' on pairs of items; if - `recur?' is #t (the default), sub-items are sorted recursively - -> can-do-edit-operation? :: (send a-list can-do-edit-operation? sym bool) - - like the method on editor<%>s; returns #f always - -> do-edit-operation :: (send a-list do-edit-operation sym bool) - - like the method on editor<%>s; does nothing - -> select-prev :: (send a-list select-prev) -> select-next :: (send a-list select-next) -> select-first :: (send a-list select-first) -> select-last :: (send a-list select-last) -> select-in :: (send a-list select-in) -> select-out :: (send a-list select-out) -> click-select :: (send a-list select i) -> page-up :: (send a-list page-up) -> page-down :: (send a-list page-down) - - Move the selection, scroll, and call on-select - -> select :: (send a-list select i) - - Like `click-select', but does not call `on-select' - unless `on-select' is always called (see `on-select-always') - -> on-select-always :: (send on-select-always) -> on-select-always :: (send on-select-always on?) - - Gets/sets whether the `on-select' method is called in - response to `select' (as opposed to `click-select'); - the default is #t - -> allow-deselect :: (send allow-deselect) -> allow-deselect :: (send allow-deselect on?) - - Gets/sets whether the `select' can be used with a #f - argument to deselect the current item (leaving none - selected); the default is #f - --------------------------------------------------- - -> hierarchical-list-item<%>, instantiate via new-item - - Methods: - -> get-editor :: (send an-item get-editor) - returns text% editor - containing the display representation of the item - -> is-selected? :: (send an-item is-selected?) - returns #t or #f - -> click-select :: (send an-item select on?) - selects or deselects - the item; hierarchical-list%'s `on-select' is called; see also - `allow-deselect' -> select :: (send an-item select on?) - like `click-select', - but `on-select' might not be called; see `on-select-always' - -> user-data :: (send an-item user-data) - returns user data; - initialized to #f -> user-data :: (send an-item user-data v) - sets user data to v - -> get-clickable-snip :: (send an-item get-clickable-snip) - - returns the snip that (when clicked) selects this element in - the list. This is intended for use with the automatic test - suite. - -> get-allow-selection? :: (send an-item get-allow-selection?) - - - returns #t or #f -- dictating if this item is allowed - to be selected. - -> set-allow-selection :: (send an-item set-allow-selection boolean) - - determines if this item is allowed to be selected - --------------------------------------------------- - -> hierarchical-list-compound-item<%>, instantiate via new-list - extends hierarchical-list-item<%> - - New methods: - -> new-item :: (send a-list-item new-item) - creates and returns a new - (empty) hierarchical-list-item<%> - -> new-item :: (send a-list-item new-item mixin) - creates and returns - a new (empty) hierarchical-list-item<%>, but first, applies - `mixin' to a class implementing hierarchical-list-item<%> and uses - the result as the class for the new hierarchical-list-item<%> - object. - -> set-no-sublists :: (send a-list set-no-sublists no-sublists?) - - avoids space to the left of the list that would normally align - non-list items with list items; this method can be called only - when the list is empty - -> new-list :: (send a-list-item new-list) - creates and returns a new - (empty) hierarchical-list-compound-item<%> - -> new-list :: (send a-list-item new-list mixin) - creates and returns - a new (empty) hierarchical-list-compound-item<%>, but first, - applies `mixin' to a class implementing - hierarchical-list-compound-item<%> and uses the result as the - class for the new hierarchical-list-compound-item<%> object. - -> delete-item :: (send a-list delete-item i) - delete - hierarchical-list-item<%> `i' from the compound item - -> get-items :: (send a-list-item get-items) - returns a list of the - items in the compound item - -> open :: (send a-list-item open) - displays the children of this list. - -> close :: (send a-list-item close) - hides the children of this list. - -> toggle-open/closed :: (send a-list-item toggle-open/closed) - - toggles the visible status of the children of this list - -> is-open? :: (send a-list-item is-open?) - - returns a boolean indicating if the children of this list are visible. - -> get-arrow-snip :: (send a-list-item get-arrow-snip) - - returns the arrow snip. intended for test suites to facilitate simulated clicks - - --------------------------------------------------- - -If you use the `find-position' and `find-snip' methods of a -hierarchical-list%, you will get back -hierarchical-item-snip% and hierarchical-list-snip% -objects. They support these methods: - -> hierarchical-item-snip% derived from editor-snip% - -> get-item :: (send a-hl-item-snip get-item) - returns the - hierarchical-list-item<%> corresponding to this snip - -> hierarchical-list-snip% derived from editor-snip% - -> get-item :: (send a-hl-list-snip get-item) - returns the - hierarchical-list-item<%> corresponding to this snip - -> get-content-buffer :: (send a-hl-list-snip get-content-buffer) - - returns the text% that contains the sub-items. - --------------------------------------------------- - -_Hierlist keystrokes_ - -Hierlists support these keystrokes: - - - down: move to the next entry at the current level (skipping lower levels) - - up: move to the previous entry at the current level (skipping lower levels) - - left: move to the enclosing level (only valid at embedded levels) - - right: move down in one level (only valid for lists) - - return: open / close the current selected level (only valid for lists) diff --git a/collects/hierlist/hierlist.ss b/collects/hierlist/hierlist.ss index 065f11d0f8..db448c646e 100644 --- a/collects/hierlist/hierlist.ss +++ b/collects/hierlist/hierlist.ss @@ -1,72 +1,4 @@ +#lang scheme/base -(module hierlist mzscheme - (require mzlib/unit - (lib "mred-sig.ss" "mred") - (lib "mred-unit.ss" "mred")) - - (require "hierlist-sig.ss" - "hierlist-unit.ss") - - (define-compound-unit/infer hl - (import) - (export hierlist^) - (link standard-mred@ hierlist@)) - - (define-values/invoke-unit/infer hl) - - (provide-signature-elements hierlist^)) - -#| - -;; Testing -(define f (make-object frame% "test")) -(define p (make-object horizontal-panel% f)) -(define c (make-object (class hierarchical-list% args - (override - [on-item-opened - (lambda (i) - (let ([f (send i user-data)]) - (when f (f i))))] - [on-select - (lambda (i) - (printf "Selected: ~a~n" - (if i - (send (send i get-editor) get-flattened-text) - i)))] - [on-double-select - (lambda (s) - (printf "Double-click: ~a~n" - (send (send s get-editor) get-flattened-text)))]) - (sequence (apply super-init args))) - p)) - -(define a (send c new-list)) -(send (send a get-editor) insert "First Item: List") -(send (send (send a new-item) get-editor) insert "Sub1") -(send (send (send a new-item) get-editor) insert "Sub2") -(define a.1 (send a new-list)) -(send (send a.1 get-editor) insert "Deeper List") -(send (send (send a.1 new-item) get-editor) insert "Way Down") - -(define b (send c new-item)) -(send (send b get-editor) insert "Second Item") - -(define d (send c new-list)) -(send (send d get-editor) insert "dynamic") -(send d user-data (lambda (d) - (time (let loop ([i 30]) - (unless (zero? i) - (send (send (send d new-item) get-editor) insert (number->string i)) - (loop (sub1 i))))))) - -(define x (send c new-list)) -(send (send x get-editor) insert "x") - -(define y (send c new-item)) -(send (send y get-editor) insert "y") - -(send f show #t) - -(yield (make-semaphore)) - -|# +(require mrlib/hierlist) +(provide (all-from-out mrlib/hierlist)) diff --git a/collects/mrlib/hierlist.ss b/collects/mrlib/hierlist.ss new file mode 100644 index 0000000000..475f38b6b0 --- /dev/null +++ b/collects/mrlib/hierlist.ss @@ -0,0 +1,65 @@ +#lang scheme/base + +(require mzlib/unit + scheme/gui/base + hierlist/hierlist-sig + hierlist/hierlist-unit) + +(define-values/invoke-unit/infer hierlist@) + +(provide-signature-elements hierlist^) + +#| + +;; Testing +(define f (make-object frame% "test")) +(define p (make-object horizontal-panel% f)) +(define c (make-object (class hierarchical-list% args + (override + [on-item-opened + (lambda (i) + (let ([f (send i user-data)]) + (when f (f i))))] + [on-select + (lambda (i) + (printf "Selected: ~a~n" + (if i + (send (send i get-editor) get-flattened-text) + i)))] + [on-double-select + (lambda (s) + (printf "Double-click: ~a~n" + (send (send s get-editor) get-flattened-text)))]) + (sequence (apply super-init args))) + p)) + +(define a (send c new-list)) +(send (send a get-editor) insert "First Item: List") +(send (send (send a new-item) get-editor) insert "Sub1") +(send (send (send a new-item) get-editor) insert "Sub2") +(define a.1 (send a new-list)) +(send (send a.1 get-editor) insert "Deeper List") +(send (send (send a.1 new-item) get-editor) insert "Way Down") + +(define b (send c new-item)) +(send (send b get-editor) insert "Second Item") + +(define d (send c new-list)) +(send (send d get-editor) insert "dynamic") +(send d user-data (lambda (d) + (time (let loop ([i 30]) + (unless (zero? i) + (send (send (send d new-item) get-editor) insert (number->string i)) + (loop (sub1 i))))))) + +(define x (send c new-list)) +(send (send x get-editor) insert "x") + +(define y (send c new-item)) +(send (send y get-editor) insert "y") + +(send f show #t) + +(yield (make-semaphore)) + +|# diff --git a/collects/mrlib/scribblings/hierlist/compound-item.scrbl b/collects/mrlib/scribblings/hierlist/compound-item.scrbl new file mode 100644 index 0000000000..02dacf0677 --- /dev/null +++ b/collects/mrlib/scribblings/hierlist/compound-item.scrbl @@ -0,0 +1,61 @@ +#lang scribble/doc +@(require "../common.ss" + (for-label mrlib/hierlist)) + +@definterface/title[hierarchical-list-compound-item<%> + (hierarchical-list-item<%>)]{ + +Instantiate this interface via @method[hierarchical-list% new-list]. + + +@defmethod[(new-item [mixin ((implementation?/c hierarchical-list-item<%>) + . -> . + (implementation?/c hierarchical-list-item<%>)) + (lambda (%) %)]) + (is-a?/c hierarchical-list-item<%>)]{ + +Like @xmethod[hierarchical-list% new-item].} + + +@defmethod[(set-no-sublists [no-sublists? any/c]) void?]{ + +Like @xmethod[hierarchical-list% set-no-sublists].} + + +@defmethod[(new-list [mixin ((implementation?/c hierarchical-list-compound-item<%>) + . -> . + (implementation?/c hierarchical-list-compound-item<%>)) + (lambda (%) %)]) + (is-a?/c hierarchical-list-compound-item<%>)]{ + +Like @xmethod[hierarchical-list% new-list].} + + +@defmethod[(delete-item [i (is-a?/c hierarchical-list-item<%>)]) void?]{ + +Deletes immediate item or sub-list @scheme[i] from the sub-list.} + + +@defmethod[(get-items) (listof (is-a?/c hierarchical-list-item<%>))]{ + +Returns a list of all immediate items in the sub-list.} + + +@defmethod*[([(open) void?] + [(close) void?] + [(toggle-open/closed) void?])]{ + +Shows or hides the items of this sub-list.} + + +@defmethod[(is-open) boolean?]{ + +Reports whether the items of this sub-list are visible.} + + +@defmethod[(get-arrow-snip) (is-a?/c snip%)]{ + +Returns a snip that corresponds to the arrow to hide/show items of the +sub-list. The result is intended for use by automatic test suites.} + +} diff --git a/collects/mrlib/scribblings/hierlist/hierlist.scrbl b/collects/mrlib/scribblings/hierlist/hierlist.scrbl new file mode 100644 index 0000000000..b6af86f75e --- /dev/null +++ b/collects/mrlib/scribblings/hierlist/hierlist.scrbl @@ -0,0 +1,36 @@ +#lang scribble/doc +@(require "../common.ss" + (for-label mrlib/hierlist)) + +@title[#:style 'toc]{Hierarchical List Control} + +@defmodule[mrlib/hierlist] + +A @scheme[hierarchical-list%] control is a list of items, some of +which can themselves be hierarchical lists. Each such sub-list has an +arrow that the user can click to hide or show the sub-list's items. + +The list control supports the following default keystrokes: + +@itemize{ + + @item{Down: move to the next entry at the current level (skipping lower levels).} + + @item{Up: move to the previous entry at the current level (skipping lower levels).} + + @item{Left: move to the enclosing level (only valid at embedded levels).} + + @item{Right: move down in one level (only valid for lists).} + + @item{Return: open/close the current selected level (only valid for lists).} + +} + + +@local-table-of-contents[] + +@include-section["list.scrbl"] +@include-section["item.scrbl"] +@include-section["compound-item.scrbl"] +@include-section["snips.scrbl"] + diff --git a/collects/mrlib/scribblings/hierlist/item.scrbl b/collects/mrlib/scribblings/hierlist/item.scrbl new file mode 100644 index 0000000000..1a938c7488 --- /dev/null +++ b/collects/mrlib/scribblings/hierlist/item.scrbl @@ -0,0 +1,46 @@ +#lang scribble/doc +@(require "../common.ss" + (for-label mrlib/hierlist)) + +@definterface/title[hierarchical-list-item<%> ()]{ + +Instantiate this interface via @method[hierarchical-list% new-item]. + +@defmethod[(get-editor) (is-a?/c text%)]{ + +Returns a text-editor buffer whose content is the display +representation of the item. In other words, fill in this text editor +to set the item's label.} + + +@defmethod[(is-selected?) boolean?]{ + +Reports whether the item is selected.} + + +@defmethod*[([(select [on? any/c]) void?] + [(click-select [on? any/c]) void?])]{ + +Calls @method[hierarchical-list% select] or @method[hierarchical-list% +click-select]. The @scheme[on?] argument can be @scheme[#f] only if +@xmethod[hierarchical-list% allow-deselect] allows it.} + + +@defmethod*[([(user-data) any/c] + [(user-data [data any/c]) void?])]{ + +Gets/sets arbitrary data associated with the item.} + + +@defmethod[(get-clickable-snip) (is-a?/c snip%)]{ + +Returns the snip that (when clicked) selects this element the +list. This method is intended for use with an automatic test suite.} + + +@defmethod*[([(get-allow-selection?) boolean?] + [(set-allow-selection [allow? any/c]) void?])]{ + +Gets/sets whether this item is allowed to be selected.} + +} diff --git a/collects/mrlib/scribblings/hierlist/list.scrbl b/collects/mrlib/scribblings/hierlist/list.scrbl new file mode 100644 index 0000000000..3bd11c1ddb --- /dev/null +++ b/collects/mrlib/scribblings/hierlist/list.scrbl @@ -0,0 +1,188 @@ +#lang scribble/doc +@(require "../common.ss" + (for-label mrlib/hierlist)) + +@defclass/title[hierarchical-list% editor-canvas% ()]{ + +Creates a hierarchical-list control. + + +@defconstructor[([parent (or/c (is-a?/c frame%) (is-a?/c dialog%) + (is-a?/c panel%) (is-a?/c pane%))] + [style (listof (one-of/c 'no-border 'control-border 'combo + 'no-hscroll 'no-vscroll + 'hide-hscroll 'hide-vscroll + 'auto-vscroll 'auto-hscroll + 'resize-corner 'deleted 'transparent)) + '(no-hscroll)])]{ + +Creates the control.} + + +@defmethod[(selected) (or/c (is-a?/c hierarchical-list-item<%>) + false/c)]{ + +Returns the currently selected item, if any.} + + +@defmethod[(new-item [mixin ((implementation?/c hierarchical-list-item<%>) + . -> . + (implementation?/c hierarchical-list-item<%>)) + (lambda (%) %)]) + (is-a?/c hierarchical-list-item<%>)]{ + +Creates and returns a new (empty) item in the list. See +@scheme[hierarchical-list-item<%>] for methods to fill in the item's +label. + +The @scheme[mixin] argument is applied to a class implementing +@scheme[hierarchical-list-item<%>], and the resulting class is +instantiated as the list item.} + + +@defmethod[(set-no-sublists [no-sublists? any/c]) void?]{ + +Enables/disables sublist mode. When sublists are disabled, space to +the left of the list items (that would normally align non-list items +with list items) is omitted. This method can be called only when the +list is empty.} + + +@defmethod[(new-list [mixin ((implementation?/c hierarchical-list-compound-item<%>) + . -> . + (implementation?/c hierarchical-list-compound-item<%>)) + (lambda (%) %)]) + (is-a?/c hierarchical-list-compound-item<%>)]{ + +Creates and returns a new (empty) sub-list in the list. See +@scheme[hierarchical-list-compound-item<%>] for methods to fill in the +item's label and content. + +The @scheme[mixin] argument is applied to a class implementing +@scheme[hierarchical-list-compound-item<%>], and the resulting class +is instantiated as the sub-list.} + + +@defmethod[(delete-item [i (is-a?/c hierarchical-list-item<%>)]) void?]{ + +Deletes immediate item or sub-list @scheme[i] from the list.} + + +@defmethod[(get-items) (listof (is-a?/c hierarchical-list-item<%>))]{ + +Returns a list of all immediate items in the list control.} + + +@defmethod*[([(selectable) boolean?] + [(selectable [on? any/c]) void?])]{ + +Reports whether items are selectable, or enables/disables item +selection.} + + +@defmethod[(on-select [i (or/c (is-a?/c hierarchical-list-item<%>) false/c)]) any]{ + +Called for new select of @scheme[i], where @scheme[i] is @scheme[#f] +if no item is now selected.} + + +@defmethod[(on-click [i (is-a?/c hierarchical-list-item<%>)]) any]{ + +Called when an item is clicked on, but selection for that item is not +allowed. Selection can be disallowed by @method[hierarchical-list% +selectable] or @xmethod[hierarchical-list-item<%> +set-allow-selection].} + + +@defmethod[(on-double-select [i (is-a?/c hierarchical-list-item<%>)]) any]{ + +Called for a double-click on @scheme[i].} + + +@defmethod[(on-item-opened [i (is-a?/c hierarchical-list-compound-item<%>)]) any]{ + +Called when the arrow for @scheme[i] is turned down.} + + +@defmethod[(on-item-closed [i (is-a?/c hierarchical-list-compound-item<%>)]) any]{ + +Called when the arrow for @scheme[i] is turned up.} + + +@defmethod[(sort [less-than-proc ((is-a?/c hierarchical-list-item<%>) + (is-a?/c hierarchical-list-item<%>) + . -> . any/c)] + [recur? any/c #t]) + void?]{ + +Sorts items in the list by calling @scheme[less-than-proc] on pairs of +items. If @scheme[recur?] is true, items in sub-lists are sorted +recursively.} + + +@defmethod[(can-do-edit-operation? [op symbol?] [recursive? any/c #t]) + boolean?]{ + +Like @xmethod[editor<%> can-do-edit-operation?]. The default +implementation always returns @scheme[#f].} + + +@defmethod[(do-edit-operation [op symbol?] [recursive? any/c #t]) + void?]{ + +Like @xmethod[editor<%> do-edit-operation]. The default implementation +does nothing.} + + +@defmethod*[([(select-prev) void?] + [(select-next) void?] + [(select-first) void?] + [(select-last) void?] + [(select-in) void?] + [(select-out) void?] + [(page-up) void?] + [(page-down) void?])]{ + +Move the selection, scroll, and call @method[hierarchical-list +on-select].} + + +@defmethod[(select [i (or/c (is-a?/c hierarchical-list-item<%>) false/c)]) void?]{ + +Moves the selection, scrolls as necessary to show it, and calls +@method[hierarchical-list% on-select] unless disabled via +@method[hierarchical-list% on-select-always]. + +The @method[hierarchical-list% allow-deselect] method controls whether +@scheme[i] is allowed to be @scheme[#f] to deselect the currently +selected item.} + + +@defmethod[(click-select [i (or/c (is-a?/c hierarchical-list-item<%>) false/c)]) void?]{ + +Like @method[hierarchical-list% select], but always calls +@method[hierarchical-list% on-select].} + + +@defmethod*[([(on-select-always) boolean?] + [(on-select-always [always? any/c]) void?])]{ + +Gets/sets whether the @method[hierarchical-list% on-select] method is +called in response to @method[hierarchical-list% select] (as opposed +to @method[hierarchical-list% click-select]). + +The initial mode enables @method[hierarchical-list% on-select] calls +always.} + + +@defmethod*[([(allow-deselect) boolean?] + [(allow-deselect [allow? any/c]) void?])]{ + + +Gets/sets whether the @method[hierarchical-list% on-select] can be +called with a @scheme[#f] argument to deselect the current item +(leaving none selected). + +The initial mode does not allow deselection.} + +} diff --git a/collects/mrlib/scribblings/hierlist/snips.scrbl b/collects/mrlib/scribblings/hierlist/snips.scrbl new file mode 100644 index 0000000000..7b3558caa9 --- /dev/null +++ b/collects/mrlib/scribblings/hierlist/snips.scrbl @@ -0,0 +1,32 @@ +#lang scribble/doc +@(require "../common.ss" + (for-label mrlib/hierlist)) + +@title{Snips in a @scheme[hierarchical-list%] Instance} + +The @xmethod[text% find-snip] method of the editor in a +@scheme[hierarchical-list%] return instances of +@scheme[hierarchical-item-snip%] and @scheme[hierarchical-list-snip%]. + +@defclass[hierarchical-item-snip% editor-snip% ()]{ + + @defmethod[(get-item) (is-a?/c hierarchical-list-item<%>)]{ + + Returns the @scheme[hierarchical-list-item<%>] corresponding to the + snip.} + +} + + +@defclass[hierarchical-list-snip% editor-snip% ()]{ + + @defmethod[(get-item) (is-a?/c hierarchical-list-compound-item<%>)]{ + + Returns the @scheme[hierarchical-list-compound-item<%>] corresponding to the + snip.} + + @defmethod[(get-content-buffer) (is-a?/c text%)]{ + + Returns the text% that contains the sub-item snips.} + +} diff --git a/collects/mrlib/scribblings/mrlib.scrbl b/collects/mrlib/scribblings/mrlib.scrbl index 956819823e..6fb5e155d2 100644 --- a/collects/mrlib/scribblings/mrlib.scrbl +++ b/collects/mrlib/scribblings/mrlib.scrbl @@ -8,10 +8,11 @@ @include-section["aligned-pasteboard/aligned-pasteboard.scrbl"] @include-section["bitmap-label.scrbl"] @include-section["cache-image-snip.scrbl"] -@include-section["interactive-value-port.scrbl"] @include-section["gif.scrbl"] @include-section["graph/graph.scrbl"] +@include-section["hierlist/hierlist.scrbl"] @include-section["include-bitmap.scrbl"] +@include-section["interactive-value-port.scrbl"] @include-section["name-message.scrbl"] @include-section["path-dialog.scrbl"] @include-section["plot.scrbl"] diff --git a/collects/scribble/latex-render.ss b/collects/scribble/latex-render.ss index 43f851f4e6..8f0a31a087 100644 --- a/collects/scribble/latex-render.ss +++ b/collects/scribble/latex-render.ss @@ -146,8 +146,8 @@ (case (string-length s) [(0) (void)] [else - (printf "{~a}" - (regexp-replace* #rx"." s "\\\\hphantom{\\\\mytexttt{x}}"))]))] + (printf "\\mbox{\\hphantom{\\mytexttt{~a}}}" + (regexp-replace* #rx"." s "x"))]))] [(newline) (printf "\\\\")] [else (error 'latex-render "unrecognzied style symbol: ~s" style)])] [(string? style) @@ -371,6 +371,7 @@ [(#\u03BB) (display "$\\lambda$")] [(#\u039B) (display "$\\Lambda$")] [(#\u03BC) (display "$\\mu$")] + [(#\u03C0) (display "$\\pi$")] [else (display c)])) (loop (add1 i)))))) diff --git a/collects/scribble/manual.ss b/collects/scribble/manual.ss index 9e2a4c71b4..b5e16f2c82 100644 --- a/collects/scribble/manual.ss +++ b/collects/scribble/manual.ss @@ -1929,7 +1929,7 @@ (list (make-element 'superscript (loop (caddr m)))) (loop (cadddr m))))] - [(regexp-match #px"^(.*)([()0-9{}\\[\\]])(.*)$" i) + [(regexp-match #px"^(.*)([()0-9{}\\[\\]\u03C0])(.*)$" i) => (lambda (m) (append (loop (cadr m)) (list (caddr m)) @@ -2056,7 +2056,7 @@ (define-struct decl (name super app-mixins intfs ranges mk-head body)) (define-struct constructor (def)) - (define-struct meth (name mode desc def)) + (define-struct meth (names mode desc def)) (define-struct spec (def)) (define-struct impl (def)) @@ -2106,8 +2106,10 @@ (cons super accum)))]))))] [ht (let ([ht (make-hasheq)]) (for-each (lambda (i) - (when (meth? i) - (hash-set! ht (meth-name i) #t))) + (cond + [(meth? i) + (for-each (lambda (name) (hash-set! ht name #t)) + (meth-names i))])) (decl-body decl)) ht)] [inh (apply @@ -2164,10 +2166,16 @@ (decl-super decl))) (id-info (decl-super decl))) (map id-info (decl-intfs decl)) - (map (lambda (m) - (meth-name m)) - (filter meth? (decl-body decl))))))))))) - + (apply + append + (map (lambda (m) + (let loop ([l (meth-names m)]) + (cond + [(null? l) null] + [(memq (car l) (cdr l)) (loop (cdr l))] + [else (cons (car l) (loop (cdr l)))]))) + (filter meth? (decl-body decl)))))))))))) + (define (build-body decl body) (append (map (lambda (i) @@ -2445,7 +2453,7 @@ (*xmethod/super (quote-syntax/loc cname) 'name1) "."))] [else null])]) - #'(make-meth 'name1 + #'(make-meth '(name ...) 'mode (lambda () (make-splice (apply append diff --git a/collects/scribblings/scribble/style.scrbl b/collects/scribblings/scribble/style.scrbl index e9bd51de3c..4c25b13840 100644 --- a/collects/scribblings/scribble/style.scrbl +++ b/collects/scribblings/scribble/style.scrbl @@ -10,13 +10,10 @@ In the descriptive body of @scheme[defform], @scheme[defproc], etc., do not start with ``This ...'' Instead, start with a sentence whose -implicit subject is the form or value being described. Capitalize the first -word. Thus, the -description will often start with ``Produces.'' Refer to arguments and -sub-forms by name. +implicit subject is the form or value being described. Capitalize the +first word. Thus, the description will often start with ``Returns'' or +``Produces.'' Refer to arguments and sub-forms by name. -@; [Eli] It's probably a good idea to say here that it's better to -@; refer to "functions" instead of "procedures". Do not use the word ``argument'' to describe a sub-form in a syntactic form; use the term ``sub-form'' instead, reserving ``argument'' for values or expressions in a function call. Refer to libraries and @@ -25,6 +22,7 @@ typeset a library or language name is called @scheme[schememodname]). Do not call an identifier (i.e., a syntactic element) a ``variable'' or a ``symbol.'' Do not use the word ``expression'' for a form that is a definition or might be a definition; use the word ``form,'' instead. +Prefer ``function'' to ``procedure.'' Avoid cut-and-paste for descriptive text. If two functions are similar, consider documenting them together with @@ -117,3 +115,15 @@ noun; use it as an annotation. Do not start a sentence with a Scheme variable name, since it is normally lowercase. For example, use ``The @scheme[_thing] argument is...'' instead of ``@scheme[_thing] is...'' + +@section{Section Titles} + +Capitalize all words except articles (``the,'' ``a,'' etc.), +prepositions, and conjunctions that are not at the start of the title. + +A manual title should normally start with a suitable keyword or key +phrase (such as ``Scribble'' for this manual) that is in boldface. If +the key word is primarily an executable name, use @scheme[exec] +instead of @scheme[bold]. Optionally add further descriptive text in +the title after a colon, where the text starting with the colon is not +in boldface. diff --git a/collects/setup/scribble.ss b/collects/setup/scribble.ss index 8df8dd49fb..76a83f8bcc 100644 --- a/collects/setup/scribble.ss +++ b/collects/setup/scribble.ss @@ -327,13 +327,13 @@ (doc-src-file doc)) (if up-to-date? ;; Load previously calculated info: - (with-handlers ([exn? (lambda (exn) - (fprintf (current-error-port) "~a\n" (exn-message exn)) - (delete-file info-out-file) - (delete-file info-in-file) - ((get-doc-info only-dirs latex-dest auto-main? - auto-user? with-record-error) - doc))]) + (with-handlers ([exn:fail? (lambda (exn) + (fprintf (current-error-port) "~a\n" (exn-message exn)) + (delete-file info-out-file) + (delete-file info-in-file) + ((get-doc-info only-dirs latex-dest auto-main? + auto-user? with-record-error) + doc))]) (let* ([v-in (with-input-from-file info-in-file read)] [v-out (with-input-from-file info-out-file read-out-sxref)]) (unless (and (equal? (car v-in) (list vers (doc-flags doc))) @@ -378,7 +378,7 @@ [ci (send renderer collect (list v) (list dest-dir))] [ri (send renderer resolve (list v) (list dest-dir) ci)] [out-v (and info-out-time - (with-handlers ([exn? (lambda (exn) #f)]) + (with-handlers ([exn:fail? (lambda (exn) #f)]) (let ([v (with-input-from-file info-out-file read-out-sxref)]) (unless (equal? (car v) (list vers (doc-flags doc))) (error "old info has wrong version or flags"))