pub struct Desktop { /* private fields */ }Expand description
The desktop group: an embedded Group that owns a Background.
A Desktop owns a Background fill and tiles
or cascades the windows inserted into it. It gives
Program a named real desktop, and it is the
first exemplar of the “a View that embeds a Group and delegates the
whole trait” pattern that Window also uses.
§Window cycling and tiling
The Command::NEXT/Command::PREV commands cycle focus through the open
windows (see Desktop::handle_event), and Alt-N selects a window by number
via Desktop::select_window_num. tile and
cascade lay the windows out — a most-equal grid or an
offset stack — driven by the program’s tile/cascade handler. When a layout
cannot fit (a cell would be zero-sized, or a window’s minimum exceeds the
cascade rect) the affected bounds are simply left unchanged.
tile_columns_first selects the grid orientation (default: rows first).
Build with Desktop::new supplying a background factory (use
Desktop::init_background for the faithful default), then drive it as any
other View.
§Turbo Vision heritage
Ports TDeskTop (tdesktop.cpp), which derived from the group class. That
inheritance becomes an embedded Group the Desktop forwards every
View method to (deviation D2); the background is recorded as a local
ViewId rather than through an owner back-pointer (deviation D3); and the
streaming machinery is dropped (deviation D12). There is no separate shutdown
phase — the tree is simply dropped.
Implementations§
Source§impl Desktop
impl Desktop
Sourcepub fn new(
bounds: Rect,
create_background: impl FnOnce(Rect) -> Option<Box<dyn View>>,
) -> Self
pub fn new( bounds: Rect, create_background: impl FnOnce(Rect) -> Option<Box<dyn View>>, ) -> Self
Construct the desktop.
Steps:
- Create the embedded group over
bounds. - Set the grow mode to grow with both the right and bottom edges.
- Default
tile_columns_firsttofalse(read bytile). - If
create_backgroundyields a view, insert it and record its id.
The background factory is injected (mirroring
Program::new); pass Desktop::init_background
for the default. The factory receives the desktop’s local-origin extent.
Sourcepub fn init_background(r: Rect) -> Box<dyn View>
pub fn init_background(r: Rect) -> Box<dyn View>
The default background factory: a Background filled with the default
shade pattern.
Sourcepub fn background(&self) -> Option<ViewId>
pub fn background(&self) -> Option<ViewId>
The id of the background child inserted during construction, if any.
Pass this to Group::put_in_front_of
(or equivalent) to send the current window behind the background, which is
exactly how Command::PREV cycles windows to the back. Returns None
only when the desktop was created without a background factory
(create_background returned None).
Sourcepub fn insert_view(&mut self, view: Box<dyn View>) -> ViewId
pub fn insert_view(&mut self, view: Box<dyn View>) -> ViewId
Insert an arbitrary view (a window) directly into the embedded group,
returning its id — the production window-insert seam. Windows must live
inside the desktop because the next/previous-window and Alt-N handlers live
on it. Used by app code that pre-populates the desktop (see
examples/hello.rs).
Sourcepub fn insert_and_focus(
&mut self,
view: Box<dyn View>,
ctx: &mut Context<'_>,
) -> ViewId
pub fn insert_and_focus( &mut self, view: Box<dyn View>, ctx: &mut Context<'_>, ) -> ViewId
Insert view into the desktop and immediately focus it — the runtime
window-open seam used by Program::desktop_insert. Combines insert_view
with a focus_child call so the new window receives keyboard input at once.
See Program::desktop_insert for the
deliberate deviation from C++ TGroup::insertView’s CanMoveFocus guard.
Trait Implementations§
Source§impl View for Desktop
impl View for Desktop
Source§fn as_any_mut(&mut self) -> Option<&mut dyn Any>
fn as_any_mut(&mut self) -> Option<&mut dyn Any>
Concrete-reach hatch used by Program::desktop_insert to downcast
&mut dyn View → &mut Desktop and call insert_and_focus.
Source§fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context<'_>)
fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context<'_>)
Lets the embedded group route the event, then handles the desktop’s own
window cycling: Command::NEXT focuses the next window and
Command::PREV sends the current window to the back (exposing the one
behind it). Both first check that the focused window will release focus, and
both consume the command afterward; any other command is left untouched.
Source§fn select_window_num(&mut self, num: i16, ctx: &mut Context<'_>) -> bool
fn select_window_num(&mut self, num: i16, ctx: &mut Context<'_>) -> bool
Select the desktop window numbered num (the Alt-N shortcut). Walks
directly into the embedded group (see Group::focus_by_number). The
program reaches this through the select_window_num trait method — not
an as_any_mut downcast — so it stays decoupled from the concrete Desktop
type.
Source§fn tile(&mut self, r: Rect)
fn tile(&mut self, r: Rect)
Lay the tileable windows into a most-equal grid of cells over r.
Factors the window count into the most-equal column/row grid, then assigns
each tileable window a cell. The first-visited (topmost) window takes the
highest-numbered slot. If a cell would be zero-width or zero-height the
layout is abandoned and bounds are left unchanged. owner_size is the
desktop size, fed to each child’s size limits inside locate.
Source§fn cascade(&mut self, r: Rect)
fn cascade(&mut self, r: Rect)
Stack the tileable windows, each offset one cell down-and-right from the previous.
The fit check uses the last-visited tileable window’s minimum size against
the full window count n; if even the deepest offset cannot fit, the layout
is abandoned and bounds are left unchanged. Otherwise each window’s top-left
is offset by a running counter, so the first-visited (topmost) window gets
the largest offset n-1 and the last gets 0.
Source§fn draw(&mut self, ctx: &mut DrawCtx<'_>)
fn draw(&mut self, ctx: &mut DrawCtx<'_>)
ctx. Must be overridden. Read moreSource§fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context<'_>)
fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context<'_>)
StateFlag::Focused, emits the focus broadcast
(RECEIVED_FOCUS/RELEASED_FOCUS) via ctx. Read moreSource§fn valid(&mut self, cmd: Command, ctx: &mut Context<'_>) -> bool
fn valid(&mut self, cmd: Command, ctx: &mut Context<'_>) -> bool
cmd (e.g. a modal end / focus
release). Base is always true. Read moreSource§fn set_modal_answer(&mut self, cmd: Command)
fn set_modal_answer(&mut self, cmd: Command)
Context::request_message_box (the
answer_to/RouteModalAnswer round-trip). Default: no-op. Overridden by
views that drive a Yes/No/Cancel prompt out of valid (e.g.
FileEditor caches it for the re-validate).Source§fn set_modal_data(&mut self, data: FieldValue)
fn set_modal_data(&mut self, data: FieldValue)
Source§fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context<'_>)
fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context<'_>)
FieldValue into this control with a Context. Default:
calls set_value (the context-free setter). Override
when scatter needs deferred publishing (e.g.
ListBox republishes its vertical scrollbar via
focus_item).Source§fn awaken(&mut self)
fn awaken(&mut self)
Source§fn calc_bounds(&mut self, owner_size: Point, delta: Point) -> Rect
fn calc_bounds(&mut self, owner_size: Point, delta: Point) -> Rect
owner_size (delta = new - old). Computes the size limits via the overridable
size_limits hook — so a widget override (e.g. a
window’s minimum) participates — then delegates the grow math to
ViewState::calc_bounds (the single source). Returns the bounds; it does
not apply them (change_bounds does).Source§fn change_bounds(&mut self, bounds: Rect)
fn change_bounds(&mut self, bounds: Rect)
bounds to this view and propagate as needed. Read moreSource§fn on_bounds_changed(&mut self, ctx: &mut Context<'_>)
fn on_bounds_changed(&mut self, ctx: &mut Context<'_>)
change_bounds is applied via
Deferred::ChangeBounds — provides a
Context for re-publishing state that depends on the new bounds (e.g. scrollbar
params). Default implementation is a no-op. Read moreSource§fn cursor_request(&self) -> Option<Point>
fn cursor_request(&self) -> Option<Point>
None to
hide it. Base: Some(cursor) iff the view is focused with a visible cursor,
else None. Read moreSource§fn caret_size(&self) -> u8
fn caret_size(&self) -> u8
CARET_INSERT (a block) when the
cursor_ins state is set, else
CARET_NORMAL (the normal caret).
The event loop reads it along the same focused chain as
cursor_request;
Group overrides it to descend into its current
child. Read moreSource§fn find_mut(&mut self, id: ViewId) -> Option<&mut dyn View>
fn find_mut(&mut self, id: ViewId) -> Option<&mut dyn View>
id to a descendant of this view (never self — the parent
identifies a view by id). A leaf has no descendants, so the base returns
None; a Group overrides to search its children
and recurse; a Group-embedding view delegates to its inner group. This is
the “tree-walk via Context” — the uniform way the event loop
/ a capture handler acts on a view it holds only by id (move a window’s
bounds, flip the dragging flag, …).Source§fn remove_descendant(&mut self, id: ViewId, ctx: &mut Context<'_>) -> bool
fn remove_descendant(&mut self, id: ViewId, ctx: &mut Context<'_>) -> bool
id from whichever group owns it.
Returns true if it was found+removed. Distinct
from find_mut because removal happens in the owner’s
child Vec (a view cannot remove itself — it doesn’t know its owner)
and must run the owning group’s reset_current. Base: false (a leaf owns
nothing).Source§fn focus_descendant(&mut self, id: ViewId, ctx: &mut Context<'_>) -> bool
fn focus_descendant(&mut self, id: ViewId, ctx: &mut Context<'_>) -> bool
id within whichever group owns it
— the tree-op behind a label focusing its linked control. Returns true
if id was found in this subtree (selectable or not — finding it stops the
walk). Distinct from find_mut because focusing happens in
the owning group (a view cannot select itself within itself): the
owning Group calls focus_child after applying the
selectable gate. Base: false (a leaf owns nothing). Read moreSource§fn has_focusable_leaf(&self) -> bool
fn has_focusable_leaf(&self) -> bool
Group
overrides to recurse into children; wrapper views delegate. Used by the
hierarchical Tab traversal to skip selectable-but-empty subtrees.Source§fn focus_to_edge(&mut self, backward: bool, ctx: &mut Context<'_>) -> bool
fn focus_to_edge(&mut self, backward: bool, ctx: &mut Context<'_>) -> bool
backward = false) or last (Shift-Tab,
backward = true) focusable leaf in this view’s subtree, establishing the
full focus path down to it. Returns true if a focusable leaf was focused. Read moreSource§fn reset_current(&mut self, ctx: &mut Context<'_>)
fn reset_current(&mut self, ctx: &mut Context<'_>)
Group::insert, so
exec_view calls this on a freshly-inserted modal BEFORE focusing it, so
the modal’s first selectable child is current on open (otherwise the modal
is keyboard-dead until a nav event — see the seam note in exec_view).
Base: no-op (a leaf has no internal currency); Group overrides;
Window/Dialog delegate.Source§fn settle_currency(&mut self, ctx: &mut Context<'_>)
fn settle_currency(&mut self, ctx: &mut Context<'_>)
Source§fn set_visible_descendant(
&mut self,
id: ViewId,
visible: bool,
ctx: &mut Context<'_>,
) -> bool
fn set_visible_descendant( &mut self, id: ViewId, visible: bool, ctx: &mut Context<'_>, ) -> bool
visible flag of the descendant named by id from its
OWNING group, running the owning group’s currency tail. Toggling
visibility on a selectable view re-picks the owner’s current child, in both
directions (show and hide). Returns true if id was found in this
subtree. Read moremenu::menu_view::update_menu_commands
implements the re-gray walk. Read moreMenuBar / MenuBox)
override to set their
MenuViewState::current — the write-only
display cache their draw reads to pick the selected colour. Read moreSource§fn get_help_ctx(&self) -> HelpCtx
fn get_help_ctx(&self) -> HelpCtx
HelpCtx::DRAGGING while the view is being dragged, otherwise the
view’s own ViewState::help_ctx. Read moreSource§fn descendant_global_bounds(&self, id: ViewId, acc: Point) -> Option<Rect>
fn descendant_global_bounds(&self, id: ViewId, acc: Point) -> Option<Rect>
id to its absolute bounds, given acc = this
view’s own absolute origin. Base returns None (a leaf owns no
descendants); a Group overrides to walk its children
accumulating origins, and a Group-embedding view delegates to its inner
group. The THistory open path needs its linked
input line’s bounds in the root/absolute frame, because exec_view
root-inserts the modal and the modal frame hit-tests in absolute coords (the
documented ROOT-INSERT + (0,0) caveat). Mirrors
find_mut’s recursion but returns geometry, not a borrow.Source§fn set_indicator_value(&mut self, location: Point, modified: bool)
fn set_indicator_value(&mut self, location: Point, modified: bool)
Indicator overrides it to store the new
cursor location + modified flag. Driven by
Deferred::IndicatorSetValue:
the editor (a leaf) cannot reach its indicator sibling inline, so it requests
this and the pump calls the method by id — virtual dispatch, not a downcast.Source§fn apply_page_sync(&mut self, idx: usize, ctx: &mut Context<'_>)
fn apply_page_sync(&mut self, idx: usize, ctx: &mut Context<'_>)
PageStack overrides it to make page idx
active. Driven by
Deferred::PageStackSync: the pump
reads the bound tab bar’s value and calls this method by id — virtual
dispatch, not a downcast.Source§fn value(&self) -> Option<FieldValue>
fn value(&self) -> Option<FieldValue>
FieldValue, or None for a view
that carries no transferable data. Read moreSource§fn set_value(&mut self, _v: FieldValue)
fn set_value(&mut self, _v: FieldValue)
FieldValue into this control. Read moreSource§fn number(&self) -> Option<i16>
fn number(&self) -> Option<i16>
None);
Window overrides to return its number when > 0
(0 means unnumbered → None).Source§fn grabs_focus_on_click(&self) -> bool
fn grabs_focus_on_click(&self) -> bool
Group::route_event). Default true (the common case); a
Button overrides to return its grab-focus flag.
A view returning false is not focused by a click but still
receives the click (so it can act, e.g. press, without becoming the
current view).Source§fn apply_scroll_sync(
&mut self,
_h: Option<i32>,
_v: Option<i32>,
_ctx: &mut Context<'_>,
)
fn apply_scroll_sync( &mut self, _h: Option<i32>, _v: Option<i32>, _ctx: &mut Context<'_>, )
None if that bar
is absent or unresolved), each read via View::value. Overridden by the
list viewers (delegate to
list_viewer::apply_scroll),
Scroller, the outline viewer, and the editor —
every sibling-scrollbar read sync routes through this one method instead of
a pump downcast. Read moreAuto Trait Implementations§
impl !RefUnwindSafe for Desktop
impl !Send for Desktop
impl !Sync for Desktop
impl !UnwindSafe for Desktop
impl Freeze for Desktop
impl Unpin for Desktop
impl UnsafeUnpin for Desktop
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
further downcast into Rc<ConcreteType> where ConcreteType implements Trait.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.