Struct SettingsState 

pub struct SettingsState {

    pub pages: Vec<SettingsPage>,
    pub selected_category: usize,
    pub selected_item: usize,
    pub focus: FocusManager<FocusPanel>,
    pub footer_button_index: usize,
    pub pending_changes: HashMap<String, Value>,
    pub visible: bool,
    pub search_query: String,
    pub search_active: bool,
    pub search_results: Vec<SearchResult>,
    pub selected_search_result: usize,
    pub search_scroll_offset: usize,
    pub search_max_visible: usize,
    pub showing_confirm_dialog: bool,
    pub confirm_dialog_selection: usize,
    pub confirm_dialog_hover: Option<usize>,
    pub showing_reset_dialog: bool,
    pub reset_dialog_selection: usize,
    pub reset_dialog_hover: Option<usize>,
    pub showing_help: bool,
    pub scroll_panel: ScrollablePanel,
    pub sub_focus: Option<usize>,
    pub editing_text: bool,
    pub hover_position: Option<(u16, u16)>,
    pub hover_hit: Option<SettingsHit>,
    pub entry_dialog_stack: Vec<EntryDialogState>,
    pub target_layer: ConfigLayer,
    pub layer_sources: HashMap<String, ConfigLayer>,
    pub pending_deletions: HashSet<String>,
    pub layout_width: u16,
    /* private fields */
}

The state of the settings UI

Fields

pages: Vec<SettingsPage>

Pages built from categories

selected_category: usize

Currently selected category index

selected_item: usize

Currently selected item index within the category

focus: FocusManager<FocusPanel>

Which panel currently has keyboard focus

footer_button_index: usize

Selected footer button index (0=Reset, 1=Save, 2=Cancel)

pending_changes: HashMap<String, Value>

Pending changes (path -> new value)

visible: bool

Whether the settings panel is visible

search_query: String

Current search query

search_active: bool

Whether search is active

search_results: Vec<SearchResult>

Current search results

selected_search_result: usize

Selected search result index

search_scroll_offset: usize

Scroll offset for search results (first visible result index)

search_max_visible: usize

Maximum number of visible search results (set during render)

showing_confirm_dialog: bool

Whether the unsaved changes confirmation dialog is showing

confirm_dialog_selection: usize

Selected option in confirmation dialog (0=Save, 1=Discard, 2=Cancel)

confirm_dialog_hover: Option<usize>

Hovered option in confirmation dialog (for mouse hover feedback)

showing_reset_dialog: bool

Whether the reset confirmation dialog is showing

reset_dialog_selection: usize

Selected option in reset dialog (0=Reset, 1=Cancel)

reset_dialog_hover: Option<usize>

Hovered option in reset dialog (for mouse hover feedback)

showing_help: bool

Whether the help overlay is showing

scroll_panel: ScrollablePanel

Scrollable panel for settings items

sub_focus: Option<usize>

Sub-focus index within the selected item (for TextList/Map navigation)

editing_text: bool

Whether we’re in text editing mode (for TextList controls)

hover_position: Option<(u16, u16)>

Current mouse hover position (for hover feedback)

hover_hit: Option<SettingsHit>

Current hover hit result (computed from hover_position and cached layout)

entry_dialog_stack: Vec<EntryDialogState>

Stack of entry dialogs (for nested editing of Maps/ObjectArrays) The top of the stack (last element) is the currently active dialog.

target_layer: ConfigLayer

Which configuration layer to save changes to. User layer is the default (global settings). Project layer saves to the current project’s .fresh/config.json.

layer_sources: HashMap<String, ConfigLayer>

Source layer for each setting path (where the value came from). Maps JSON pointer paths (e.g., “/editor/tab_size”) to their source layer. Values not in this map come from system defaults.

pending_deletions: HashSet<String>

Paths to be removed from the current layer on save. When a user “resets” a setting, we remove it from the delta rather than setting it to the schema default.

layout_width: u16

Last known layout width for description wrapping. Set during render and propagated to items for height calculations.

Implementations

impl SettingsState

pub fn new(schema_json: &str, config: &Config) -> Result<Self, Error>

Create a new settings state from schema and current config

pub fn focus_panel(&self) -> FocusPanel

Get the currently focused panel

pub fn show(&mut self)

Show the settings panel

pub fn hide(&mut self)

Hide the settings panel

pub fn entry_dialog(&self) -> Option<&EntryDialogState>

Get the current entry dialog (top of stack), if any

pub fn entry_dialog_mut(&mut self) -> Option<&mut EntryDialogState>

Get the current entry dialog mutably (top of stack), if any

pub fn has_entry_dialog(&self) -> bool

Check if any entry dialog is open

pub fn current_page(&self) -> Option<&SettingsPage>

Get the currently selected page

pub fn current_page_mut(&mut self) -> Option<&mut SettingsPage>

Get the currently selected page mutably

pub fn current_item(&self) -> Option<&SettingItem>

Get the currently selected item

pub fn current_item_mut(&mut self) -> Option<&mut SettingItem>

Get the currently selected item mutably

pub fn can_exit_text_editing(&self) -> bool

Check if the current text field can be exited (valid JSON if required)

pub fn entry_dialog_can_exit_text_editing(&self) -> bool

Check if entry dialog’s current text field can be exited (valid JSON if required)

pub fn select_prev(&mut self)

Move selection up

pub fn select_next(&mut self)

Move selection down

pub fn select_next_page(&mut self)

Move selection down by a page (viewport height worth of items)

pub fn select_prev_page(&mut self)

Move selection up by a page (viewport height worth of items)

pub fn toggle_focus(&mut self)

Switch focus between panels: Categories -> Settings -> Footer -> Categories

pub fn toggle_focus_backward(&mut self)

Switch focus to the previous panel: Categories <- Settings <- Footer <- Categories

pub fn update_layout_widths(&mut self)

Ensure the selected item is visible in the viewport Update layout_width on all items in the current page. Called before any scroll calculations so heights are correct.

pub fn ensure_visible(&mut self)

pub fn set_pending_change(&mut self, path: &str, value: Value)

Record a pending change for a setting

pub fn has_changes(&self) -> bool

Check if there are unsaved changes

pub fn apply_changes(&self, config: &Config) -> Result<Config, Error>

Apply pending changes to a config

pub fn discard_changes(&mut self)

Discard all pending changes

pub fn set_target_layer(&mut self, layer: ConfigLayer)

Set the target layer for saving changes.

pub fn cycle_target_layer(&mut self)

Cycle through writable layers: User -> Project -> Session -> User

pub fn target_layer_name(&self) -> &'static str

Get a display name for the current target layer.

pub fn set_layer_sources(&mut self, sources: HashMap<String, ConfigLayer>)

Set the layer sources map (called by Editor when opening settings). This also rebuilds pages to update modified indicators.

pub fn get_layer_source(&self, path: &str) -> ConfigLayer

Get the source layer for a setting path. Returns the layer where this value was defined, or System if it’s the default.

pub fn layer_source_label(layer: ConfigLayer) -> &'static str

Get a short label for a layer source (for UI display).

pub fn reset_current_to_default(&mut self)

Reset the current item by removing it from the target layer.

NEW SEMANTICS: Instead of setting to schema default, we remove the value from the current layer’s delta. The value then falls back to inherited (from lower-precedence layers) or to the schema default.

Only items defined in the target layer can be reset.

pub fn on_value_changed(&mut self)

Handle a value change from user interaction

pub fn update_focus_states(&mut self)

Update focus states for rendering

pub fn start_search(&mut self)

Start search mode

pub fn cancel_search(&mut self)

Cancel search mode

pub fn set_search_query(&mut self, query: String)

Update search query and refresh results

pub fn search_push_char(&mut self, c: char)

Add a character to the search query

pub fn search_pop_char(&mut self)

Remove the last character from the search query

pub fn search_prev(&mut self)

Navigate to previous search result

pub fn search_next(&mut self)

Navigate to next search result

pub fn search_scroll_up(&mut self, delta: usize) -> bool

Scroll search results up by delta items

pub fn search_scroll_down(&mut self, delta: usize) -> bool

Scroll search results down by delta items

pub fn search_scroll_to_ratio(&mut self, ratio: f32) -> bool

Scroll search results to a ratio (0.0 = top, 1.0 = bottom)

pub fn jump_to_search_result(&mut self)

Jump to the currently selected search result

pub fn current_search_result(&self) -> Option<&SearchResult>

Get the currently selected search result

pub fn show_confirm_dialog(&mut self)

Show the unsaved changes confirmation dialog

pub fn hide_confirm_dialog(&mut self)

Hide the confirmation dialog

pub fn confirm_dialog_next(&mut self)

Move to next option in confirmation dialog

pub fn confirm_dialog_prev(&mut self)

Move to previous option in confirmation dialog

pub fn toggle_help(&mut self)

Toggle the help overlay

pub fn hide_help(&mut self)

Hide the help overlay

pub fn showing_entry_dialog(&self) -> bool

Check if the entry dialog is showing

pub fn open_entry_dialog(&mut self)

Open the entry dialog for the currently focused map entry

pub fn open_add_entry_dialog(&mut self)

Open entry dialog for adding a new entry (with empty key)

pub fn open_add_array_item_dialog(&mut self)

Open dialog for adding a new array item

pub fn open_edit_array_item_dialog(&mut self)

Open dialog for editing an existing array item

pub fn close_entry_dialog(&mut self)

Close the entry dialog without saving (pops from stack)

pub fn open_nested_entry_dialog(&mut self)

Open a nested entry dialog for a Map or ObjectArray field within the current dialog

This enables recursive editing: if a dialog field is itself a Map or ObjectArray, pressing Enter will open a new dialog on top of the stack for that nested structure.

pub fn save_entry_dialog(&mut self)

Save the entry dialog and apply changes

Automatically detects whether this is a Map or ObjectArray dialog and handles saving appropriately.

pub fn delete_entry_dialog(&mut self)

Delete the entry from the map and close the dialog

pub fn max_scroll(&self) -> u16

Get the maximum scroll offset for the current page (in rows)

pub fn scroll_up(&mut self, delta: usize) -> bool

Scroll up by a given number of rows Returns true if the scroll offset changed

pub fn scroll_down(&mut self, delta: usize) -> bool

Scroll down by a given number of rows Returns true if the scroll offset changed

pub fn scroll_to_ratio(&mut self, ratio: f32) -> bool

Scroll to a position based on a ratio (0.0 to 1.0) Returns true if the scroll offset changed

pub fn is_number_control(&self) -> bool

Start text editing mode for TextList, Text, or Map controls Check if the current control is a number input

pub fn start_editing(&mut self)

pub fn stop_editing(&mut self)

Stop text editing mode

pub fn is_editable_control(&self) -> bool

Check if the current item is editable (TextList, Text, Map, or Json)

pub fn is_editing_json(&self) -> bool

Check if currently editing a JSON control

pub fn text_insert(&mut self, c: char)

Insert a character into the current editable control

pub fn text_backspace(&mut self)

Backspace in the current editable control

pub fn text_move_left(&mut self)

Move cursor left in the current editable control

pub fn text_move_right(&mut self)

Move cursor right in the current editable control

pub fn text_focus_prev(&mut self)

Move focus to previous item in TextList/Map (wraps within control)

pub fn text_focus_next(&mut self)

Move focus to next item in TextList/Map (wraps within control)

pub fn text_add_item(&mut self)

Add new item in TextList/Map (from the new item field)

pub fn text_remove_focused(&mut self)

Remove the currently focused item in TextList/Map

pub fn json_cursor_up(&mut self)

Move cursor up in JSON editor

pub fn json_cursor_down(&mut self)

Move cursor down in JSON editor

pub fn json_insert_newline(&mut self)

Insert newline in JSON editor

pub fn json_delete(&mut self)

Delete character at cursor in JSON editor

pub fn json_exit_editing(&mut self)

Stop JSON editing: commit if valid, revert if invalid

pub fn json_select_all(&mut self)

Select all text in JSON editor

pub fn json_selected_text(&self) -> Option<String>

Get selected text from JSON editor

pub fn json_cursor_up_selecting(&mut self)

Move cursor up with selection in JSON editor

pub fn json_cursor_down_selecting(&mut self)

Move cursor down with selection in JSON editor

pub fn json_cursor_left_selecting(&mut self)

Move cursor left with selection in JSON editor

pub fn json_cursor_right_selecting(&mut self)

Move cursor right with selection in JSON editor

pub fn is_dropdown_open(&self) -> bool

Check if current item is a dropdown with menu open

pub fn dropdown_toggle(&mut self)

Toggle dropdown open/closed

pub fn dropdown_prev(&mut self)

Select previous option in dropdown

pub fn dropdown_next(&mut self)

Select next option in dropdown

pub fn dropdown_home(&mut self)

Jump to first option in dropdown

pub fn dropdown_end(&mut self)

Jump to last option in dropdown

pub fn dropdown_confirm(&mut self)

Confirm dropdown selection (close and record change)

pub fn dropdown_cancel(&mut self)

Cancel dropdown (restore original value and close)

pub fn dropdown_select(&mut self, option_idx: usize)

Select a specific dropdown option by index and confirm

pub fn set_dropdown_hover(&mut self, hover_idx: Option<usize>) -> bool

Set dropdown hover index (for mouse hover indication) Returns true if the hover index changed

pub fn dropdown_scroll(&mut self, delta: i32)

Scroll open dropdown by delta (positive = down, negative = up)

pub fn is_number_editing(&self) -> bool

Check if current item is a number input being edited

pub fn start_number_editing(&mut self)

Start number editing mode

pub fn number_insert(&mut self, c: char)

Insert a character into number input

pub fn number_backspace(&mut self)

Backspace in number input

pub fn number_confirm(&mut self)

Confirm number editing

pub fn number_cancel(&mut self)

Cancel number editing

pub fn number_delete(&mut self)

Delete character forward in number input

pub fn number_move_left(&mut self)

Move cursor left in number input

pub fn number_move_right(&mut self)

Move cursor right in number input

pub fn number_move_home(&mut self)

Move cursor to start of number input

pub fn number_move_end(&mut self)

Move cursor to end of number input

pub fn number_move_left_selecting(&mut self)

Move cursor left selecting in number input

pub fn number_move_right_selecting(&mut self)

Move cursor right selecting in number input

pub fn number_move_home_selecting(&mut self)

Move cursor to start selecting in number input

pub fn number_move_end_selecting(&mut self)

Move cursor to end selecting in number input

pub fn number_move_word_left(&mut self)

Move word left in number input

pub fn number_move_word_right(&mut self)

Move word right in number input

pub fn number_move_word_left_selecting(&mut self)

Move word left selecting in number input

pub fn number_move_word_right_selecting(&mut self)

Move word right selecting in number input

pub fn number_select_all(&mut self)

Select all text in number input

pub fn number_delete_word_backward(&mut self)

Delete word backward in number input

pub fn number_delete_word_forward(&mut self)

Delete word forward in number input

pub fn get_change_descriptions(&self) -> Vec<String>

Get list of pending changes for display

Trait Implementations

impl Debug for SettingsState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl InputHandler for SettingsState

fn handle_key_event( &mut self, event: &KeyEvent, ctx: &mut InputContext, ) -> InputResult

Handle a key event. Returns whether the event was consumed.

fn is_modal(&self) -> bool

Whether this handler is modal (consumes all unhandled input).

fn focused_child(&self) -> Option<&dyn InputHandler>

Get the currently focused child handler, if any.

fn focused_child_mut(&mut self) -> Option<&mut dyn InputHandler>

Get the currently focused child handler mutably, if any.

fn dispatch_input( &mut self, event: &KeyEvent, ctx: &mut InputContext, ) -> InputResult

Dispatch input through this handler and its children. This is the main entry point - it handles the bubble-up logic.