pub struct FileEditor {
pub editor: Editor,
pub file_name: Option<PathBuf>,
pub pending_title_update: bool,
/* private fields */
}Expand description
An Editor backed by a file on disk. An embed-and-delegate wrapper; the
editor runs in file-editor mode (growable buffer plus save commands).
It loads and saves over real std::fs, grows the buffer to fit a file, and
handles the save commands. Validation runs the full modified-save
Yes/No/Cancel prompt and a write-error popup, both through the
async-modal-from-a-view mechanism: valid requests a message box, caches the
answer in set_modal_answer, then re-validates.
Save-as (an explicit Save-As command, or saving an untitled buffer) opens a
file dialog through Context::request_save_as_dialog: the loop builds and
runs the dialog, the completion sets file_name plus pending_title_update
and re-injects a Save command, which writes the file and broadcasts a
title-update (refreshing the hosting EditWindow’s frame title).
A read error is reported through a message box on the first event (the
constructor has no Context, so the error is cached at load time).
Optional backup files (off by default) append ~ to the filename
(foo.txt → foo.txt~), following the Unix convention.
A couple of details collapse on a modern host: std::fs::write does not
distinguish create-vs-write failure, so both report one “Error writing file …”
box, and buffer growth is infallible, so there is no out-of-memory path.
§Turbo Vision heritage
Ports TFileEditor (tfiledtr.cpp). Data exchange uses the typed value
protocol (deviation D10); serialization is dropped.
Fields§
§editor: EditorThe editor engine, in file-editor mode.
file_name: Option<PathBuf>The backing file path, or None for an untitled (unsaved) buffer.
Set at construction time if a path was provided, then updated by the
save-as dialog completion. Read this to determine the current title or
whether a buffer has ever been saved. Do not mutate it directly; let
save / the save-as dialog completion update it.
pending_title_update: boolSet by the save-as dialog completion (after the user picks a filename) so
the next successful save broadcasts a title-update to refresh the hosting
EditWindow’s frame title. The broadcast is deferred to the re-injected
save so it fires from a full Context.
Implementations§
Source§impl FileEditor
impl FileEditor
Sourcepub fn new(
bounds: Rect,
h_scroll_bar: Option<ViewId>,
v_scroll_bar: Option<ViewId>,
indicator: Option<ViewId>,
file_name: Option<PathBuf>,
) -> Self
pub fn new( bounds: Rect, h_scroll_bar: Option<ViewId>, v_scroll_bar: Option<ViewId>, indicator: Option<ViewId>, file_name: Option<PathBuf>, ) -> Self
Create a file-backed editor wired to the given scroll bars and frame indicator.
Pass a file_name to open an existing file: the path is expanded to
absolute and the file is read immediately. None starts an untitled buffer
you can save later via FileEditor::save. A missing file is treated as an
empty buffer (not an error); a real I/O error is reported the first time
handle_event runs (the constructor has no Context for modal dialogs).
This constructor is called by EditWindow::new — prefer that for the
typical “open a file in a window” use case.
Sourcepub fn load_file(&mut self) -> bool
pub fn load_file(&mut self) -> bool
Read file_name into the buffer, growing it to fit.
A missing or unopenable file is treated as an empty buffer (returns true,
matching the C++ behavior). A real read error stores a message in
pending_load_error and returns false; the message is shown via a modal
dialog on the first handle_event call (the constructor has no Context).
Call this after changing file_name to reload from the new path. The buffer
is grown infallibly to fit the file — there is no out-of-memory failure path.
Sourcepub fn save_file(&mut self, ctx: &mut Context<'_>) -> bool
pub fn save_file(&mut self, ctx: &mut Context<'_>) -> bool
Write the buffer’s logical text to file_name and clear the dirty flag.
Returns false and pops an error dialog on failure. If the
EF_BACKUP_FILES flag is set in the editor’s editor_flags, the existing
file is renamed to <name>~ before writing.
Call save rather than this directly — save handles
the untitled case by opening a save-as dialog first.
Sourcepub fn save(&mut self, ctx: &mut Context<'_>) -> bool
pub fn save(&mut self, ctx: &mut Context<'_>) -> bool
Save the buffer to disk, opening a file-picker dialog if the buffer is untitled.
If file_name is set, delegates immediately to save_file.
If the buffer is untitled, requests an async save-as dialog (a leaf view cannot
run a blocking dialog inline): the dialog runs on the next event-loop pump,
sets file_name, and re-injects a Save command that triggers a second call
to save, this time with file_name set.
Returns false when the save is deferred (untitled path) or when writing
fails; true on a successful write. Normally invoked via the Save command
in handle_event — callers rarely need to call this directly.
Trait Implementations§
Source§impl View for FileEditor
impl View for FileEditor
Source§fn as_any_mut(&mut self) -> Option<&mut dyn Any>
fn as_any_mut(&mut self) -> Option<&mut dyn Any>
Concrete-reach hatch: the pump’s save-as brokers and
EditWindow::handle_event downcast a group child back to &mut FileEditor
to set file_name / read pending_title_update. WITHOUT this override the
#[delegate(to = editor)] macro would forward as_any_mut to the inner
Editor, so the downcast would silently miss (returning the inner
editor’s Any).
Source§fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context<'_>)
fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context<'_>)
Handle events for the file editor: delegates to the inner Editor, then
processes Save and Save-As commands and deferred load errors.
Load-error popup: if load_file stored an error at construction time it
is popped as a modal dialog on the first event (the constructor has no
Context for dialogs).
Save-As: opens a file-picker dialog asynchronously; the completion sets
file_name, sets pending_title_update, and re-injects a Save command.
Save: calls save, flushes the update flags, and —
when pending_title_update is set — broadcasts cmUpdateTitle to refresh
every open EditWindow’s frame title.
Source§fn valid(&mut self, cmd: Command, ctx: &mut Context<'_>) -> bool
fn valid(&mut self, cmd: Command, ctx: &mut Context<'_>) -> bool
Validity check. For the plain validity command this reflects buffer validity; for any other command, a modified buffer first prompts a Yes/No/Cancel save dialog, and the answer decides the result: Yes → save, No → clear the dirty flag and allow, Cancel → veto.
The prompt is asynchronous: the first call requests the box
(Context::request_message_box, routing the answer back to this view and
re-posting the close command) and returns false (veto for now). When the
user picks, the pump routes the answer back through
View::set_modal_answer (caching it in pending_save_answer) and
re-posts the close, which re-runs this check; this time the cached choice is
applied.
Source§fn set_modal_answer(&mut self, cmd: Command)
fn set_modal_answer(&mut self, cmd: Command)
Cache the user’s Yes/No/Cancel choice from the modified-save box for the re-validate pass (the async-modal-from-a-view round-trip).
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 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 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 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 select_window_num(&mut self, num: i16, ctx: &mut Context<'_>) -> bool
fn select_window_num(&mut self, num: i16, ctx: &mut Context<'_>) -> bool
num. Returns
whether one matched. Consistent with the find_mut /
remove_descendant tree-op family: the live
loop holds a subtree only by id (here, the desktop) and asks it to act.
Default: no-op (false). Desktop overrides.Source§fn tile(&mut self, r: Rect)
fn tile(&mut self, r: Rect)
Desktop lays out
windows). r is the desktop-local layout rect. Mirrors
select_window_num: the live loop drives the
desktop by id through &mut dyn View.Source§fn cascade(&mut self, r: Rect)
fn cascade(&mut self, r: Rect)
Desktop overrides.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 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.Auto Trait Implementations§
impl Freeze for FileEditor
impl RefUnwindSafe for FileEditor
impl Send for FileEditor
impl Sync for FileEditor
impl Unpin for FileEditor
impl UnsafeUnpin for FileEditor
impl UnwindSafe for FileEditor
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.