Guide API
Skip to main content

FileEditor

Struct FileEditor 

Source
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: Editor

The 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: bool

Set 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

Source

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.

Source

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.

Source

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.

Source

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

Source§

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<'_>)

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

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)

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 state(&self) -> &ViewState

Borrow the embedded ViewState (the view’s data members).
Source§

fn state_mut(&mut self) -> &mut ViewState

Mutably borrow the embedded ViewState.
Source§

fn draw(&mut self, ctx: &mut DrawCtx<'_>)

Paint the view through ctx. Must be overridden. Read more
Source§

fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context<'_>)

Flip a propagating state flag and run its side effects. The base flips the flag and, for StateFlag::Focused, emits the focus broadcast (RECEIVED_FOCUS/RELEASED_FOCUS) via ctx. Read more
Source§

fn value(&self) -> Option<FieldValue>

This control’s current value as a FieldValue, or None for a view that carries no transferable data. Read more
Source§

fn set_value(&mut self, v: FieldValue)

Load a typed FieldValue into this control. Read more
Source§

fn set_modal_data(&mut self, data: FieldValue)

Deliver a finished modal’s typed result record to the view that launched it. Defaulted no-op; a launcher view overrides it to load the record. Two producers call it: Read more
Source§

fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context<'_>)

Scatter a typed 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)

Post-construction initialization hook. Called once after the view has been inserted into its group and the group’s layout is complete — the earliest point at which a view may safely resolve sibling ids or run initialization that requires a fully-wired tree. Override when a widget needs to do work that cannot happen during construction (e.g. reading a linked control’s current value). Base is a no-op.
Source§

fn size_limits(&self, owner_size: Point) -> (Point, Point)

The (min, max) size this view may take inside an owner of owner_size. Read more
Source§

fn calc_bounds(&mut self, owner_size: Point, delta: Point) -> Rect

The new bounds after the owner resized to 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)

Apply bounds to this view and propagate as needed. Read more
Source§

fn on_bounds_changed(&mut self, ctx: &mut Context<'_>)

Called by the pump after 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 more
Source§

fn cursor_request(&self) -> Option<Point>

The view-local hardware-cursor position this view wants shown, or None to hide it. Base: Some(cursor) iff the view is focused with a visible cursor, else None. Read more
Source§

fn caret_size(&self) -> u8

The caret size this view wants while its cursor is shown, as a percentage of the character cell (1..=100). Base: 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 more
Source§

fn find_mut(&mut self, id: ViewId) -> Option<&mut dyn View>

Resolve 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

Remove the descendant named by 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

Focus (select) the descendant named by 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 more
Source§

fn has_focusable_leaf(&self) -> bool

Whether this view’s subtree contains a focusable leaf (visible, enabled, selectable). Base: whether THIS view is itself a focusable leaf; 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

Focus the first (Tab, 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 more
Source§

fn reset_current(&mut self, ctx: &mut Context<'_>)

Establish this view’s INTERNAL currency — for a group-bearing view, set its current child to the first visible+selectable child. The insert-time currency cascade cannot run inside the context-less 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<'_>)

Run any pending insert-time reset-current cascades in this subtree. Read more
Source§

fn set_visible_descendant( &mut self, id: ViewId, visible: bool, ctx: &mut Context<'_>, ) -> bool

Tree-op: set the 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 more
Source§

fn number(&self) -> Option<i16>

The window number for Alt-N selection. Base views are unnumbered (None); Window overrides to return its number when > 0 (0 means unnumbered → None).
Source§

fn grabs_focus_on_click(&self) -> bool

Whether a mouse-down inside this view should auto-select (focus) it — the per-view opt-out for the group’s mouse-down auto-select (see 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

Tree-op: ask this subtree to select the window numbered 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)

Tree-op: lay this subtree’s tileable windows out in a grid (the tile command). Base: no-op (only 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)

Tree-op: lay this subtree’s tileable windows out cascaded (the cascade command). Base: no-op; Desktop overrides.
Source§

fn apply_scroll_sync( &mut self, h: Option<i32>, v: Option<i32>, ctx: &mut Context<'_>, )

The shared scrollbar read-sync broker hook. Defaulted no-op; scroll-aware widgets override it to apply a freshly-read scrollbar delta to themselves. The pump passes the horizontal/vertical scrollbar values (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 more
Source§

fn update_menu_commands(&mut self, cs: &CommandSet)

The menu command-graying broker hook. Defaulted no-op; menu views override to re-gray their menu tree against the program’s live disabled-command set (denylist — the argument is the set of commands currently disabled; an item grays iff its command is in it). The free fn menu::menu_view::update_menu_commands implements the re-gray walk. Read more
Source§

fn set_menu_current(&mut self, current: Option<usize>)

The menu-highlight write-back hook. Defaulted no-op; menu views (MenuBar / MenuBox) override to set their MenuViewState::current — the write-only display cache their draw reads to pick the selected colour. Read more
Source§

fn get_help_ctx(&self) -> HelpCtx

The effective help context for status-line switching. Returns HelpCtx::DRAGGING while the view is being dragged, otherwise the view’s own ViewState::help_ctx. Read more
Source§

fn descendant_global_bounds(&self, id: ViewId, acc: Point) -> Option<Rect>

Resolve descendant 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)

The editor→indicator status-push broker hook. Defaulted no-op; the editor’s status 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<'_>)

The tab-bar→page-stack switch broker hook. Defaulted no-op; 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§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert 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>

Convert 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)

Convert &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)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> ⓘ

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.