use iced::{
Alignment, Element, Length, Padding,
widget::{Space, button, column, container, row, scrollable, text},
};
use knotra_ui::i18n::Locale;
use knotra_ui::widget::validated_field;
use crate::{
message::{Message, SettingsMessage},
state::AppState,
view::dashboard::WidthMode,
};
const FORM_MAX_WIDTH: f32 = 680.0;
pub fn view(state: &AppState) -> Element<'_, Message> {
let header = view_header(state);
let body = view_body(state);
column![header, scrollable(body).height(Length::Fill)]
.height(Length::Fill)
.into()
}
fn view_header(state: &AppState) -> Element<'_, Message> {
row![text(state.t("settings.title")).size(20)]
.spacing(12)
.align_y(Alignment::Center)
.padding(Padding::new(12.0))
.into()
}
fn view_body(state: &AppState) -> Element<'_, Message> {
let mode = state.width_mode;
let form = column![
section_header(state.t("settings.section.display")),
view_display_section(state),
section_header(state.t("settings.section.refresh")),
field_grid(
mode,
vec![
view_refresh_interval_field(state),
view_max_concurrent_field(state),
],
),
section_header(state.t("settings.section.tools")),
field_grid(
mode,
vec![view_editor_field(state), view_merge_tool_field(state)]
),
section_header(state.t("settings.section.logs")),
view_max_logs_field(state),
section_header(state.t("settings.section.fs_watch")),
view_fs_watch_section(state),
view_save_row(state),
text(state.t("settings.restart_hint")).size(11),
]
.spacing(16)
.width(Length::Fill)
.max_width(FORM_MAX_WIDTH);
container(form).padding(24).center_x(Length::Fill).into()
}
fn field_grid<'a>(mode: WidthMode, cells: Vec<Element<'a, Message>>) -> Element<'a, Message> {
match mode {
WidthMode::Compact => column(cells).spacing(16).into(),
WidthMode::Standard | WidthMode::Wide => row(cells).spacing(16).into(),
}
}
fn view_display_section(state: &AppState) -> Element<'_, Message> {
let locale_row = row![
text(state.t("settings.locale_label")).size(13),
Space::new().width(Length::Fill),
button(text("English")).on_press_maybe(if state.config.locale != Locale::En {
Some(Message::Settings(SettingsMessage::LocaleChanged(
Locale::En,
)))
} else {
None
}),
button(text("日本語")).on_press_maybe(if state.config.locale != Locale::Ja {
Some(Message::Settings(SettingsMessage::LocaleChanged(
Locale::Ja,
)))
} else {
None
}),
]
.spacing(8)
.align_y(Alignment::Center);
let theme_row = row![
text(state.t("settings.theme_label")).size(13),
Space::new().width(Length::Fill),
button(text(state.t("settings.theme_dark"))).on_press_maybe(if !state.config.dark_theme {
Some(Message::Settings(SettingsMessage::ThemeChanged(true)))
} else {
None
}),
button(text(state.t("settings.theme_light"))).on_press_maybe(if state.config.dark_theme {
Some(Message::Settings(SettingsMessage::ThemeChanged(false)))
} else {
None
}),
]
.spacing(8)
.align_y(Alignment::Center);
let active_locale_note = format!(
"{} {}",
state.t("settings.active_prefix"),
state.config.locale
);
let active_theme_note = format!(
"{} {}",
state.t("settings.active_prefix"),
if state.config.dark_theme {
state.t("settings.theme_dark")
} else {
state.t("settings.theme_light")
}
);
column![
locale_row,
text(active_locale_note).size(11),
theme_row,
text(active_theme_note).size(11),
]
.spacing(8)
.into()
}
fn view_refresh_interval_field(state: &AppState) -> Element<'_, Message> {
let tokens = &state.theme.tokens;
let value = &state.settings_edit.refresh_interval_secs;
let error = u32_field_error(value).map(|key| state.t(key));
validated_field(
tokens,
state.t("settings.refresh_interval_label"),
"60",
value,
Some(state.t("settings.unit_seconds")),
|s| Message::Settings(SettingsMessage::RefreshIntervalChanged(s)),
error,
)
}
fn view_max_concurrent_field(state: &AppState) -> Element<'_, Message> {
let tokens = &state.theme.tokens;
let value = &state.settings_edit.max_concurrent_reads;
let error = positive_usize_field_error(value).map(|key| state.t(key));
validated_field(
tokens,
state.t("settings.max_concurrent_label"),
"8",
value,
None,
|s| Message::Settings(SettingsMessage::MaxConcurrentChanged(s)),
error,
)
}
fn view_max_logs_field(state: &AppState) -> Element<'_, Message> {
let tokens = &state.theme.tokens;
let value = &state.settings_edit.max_log_entries;
let error = positive_usize_field_error(value).map(|key| state.t(key));
validated_field(
tokens,
state.t("settings.max_logs_label"),
"200",
value,
None,
|s| Message::Settings(SettingsMessage::MaxLogEntriesChanged(s)),
error,
)
}
fn view_editor_field(state: &AppState) -> Element<'_, Message> {
let tokens = &state.theme.tokens;
validated_field(
tokens,
state.t("settings.editor_label"),
state.t("settings.editor_hint"),
&state.settings_edit.external_editor,
None,
|s| Message::Settings(SettingsMessage::ExternalEditorChanged(s)),
None,
)
}
fn view_merge_tool_field(state: &AppState) -> Element<'_, Message> {
let tokens = &state.theme.tokens;
validated_field(
tokens,
state.t("settings.merge_tool_label"),
state.t("settings.merge_tool_hint"),
&state.settings_edit.external_merge_tool,
None,
|s| Message::Settings(SettingsMessage::ExternalMergeToolChanged(s)),
None,
)
}
fn view_fs_debounce_field(state: &AppState) -> Element<'_, Message> {
let tokens = &state.theme.tokens;
let value = &state.settings_edit.fs_debounce_secs;
let error = u32_field_error(value).map(|key| state.t(key));
validated_field(
tokens,
state.t("settings.fs_watch_interval_label"),
"2",
value,
Some(state.t("settings.unit_seconds")),
|s| Message::Settings(SettingsMessage::FsDebounceSecs(s)),
error,
)
}
fn u32_field_error(s: &str) -> Option<&'static str> {
s.parse::<u32>()
.is_err()
.then_some("settings.error.invalid_number")
}
fn positive_usize_field_error(s: &str) -> Option<&'static str> {
let valid = s.parse::<usize>().is_ok_and(|n| n > 0);
(!valid).then_some("settings.error.invalid_positive_number")
}
fn view_fs_watch_section(state: &AppState) -> Element<'_, Message> {
column![
labeled_row(
state.t("settings.fs_watch_enable_label"),
button(text(if state.config.fs_watch_enabled {
state.t("settings.fs_watch_enabled")
} else {
state.t("settings.fs_watch_disabled")
}))
.on_press(Message::Settings(SettingsMessage::FsWatchEnabledChanged(
!state.config.fs_watch_enabled
)))
.into(),
),
text(state.t("settings.fs_watch_hint")).size(11),
view_fs_debounce_field(state),
]
.spacing(12)
.into()
}
fn view_save_row(state: &AppState) -> Element<'_, Message> {
let save_btn = button(text(state.t("settings.save")))
.on_press(Message::Settings(SettingsMessage::SaveRequested));
let save_msg: Element<'_, Message> = if let Some(ref msg) = state.settings_save_msg {
text(msg.as_str()).size(13).into()
} else {
Space::new().into()
};
row![save_btn, save_msg]
.spacing(12)
.align_y(Alignment::Center)
.padding([8, 0])
.into()
}
fn section_header(label: &str) -> Element<'_, Message> {
text(label).size(15).into()
}
fn labeled_row<'a>(label: &'a str, widget: Element<'a, Message>) -> Element<'a, Message> {
row![
text(label).size(13),
Space::new().width(Length::Fill),
widget,
]
.align_y(Alignment::Center)
.into()
}
#[cfg(test)]
mod tests {
use super::{positive_usize_field_error, u32_field_error};
#[test]
fn u32_field_accepts_zero_and_any_parseable_value() {
assert_eq!(u32_field_error("0"), None);
assert_eq!(u32_field_error("60"), None);
assert_eq!(
u32_field_error("abc"),
Some("settings.error.invalid_number")
);
assert_eq!(u32_field_error(""), Some("settings.error.invalid_number"));
assert_eq!(u32_field_error("-1"), Some("settings.error.invalid_number"));
}
#[test]
fn positive_usize_field_rejects_zero_and_unparseable() {
assert_eq!(positive_usize_field_error("8"), None);
assert_eq!(positive_usize_field_error("1"), None);
assert_eq!(
positive_usize_field_error("0"),
Some("settings.error.invalid_positive_number")
);
assert_eq!(
positive_usize_field_error("abc"),
Some("settings.error.invalid_positive_number")
);
assert_eq!(
positive_usize_field_error(""),
Some("settings.error.invalid_positive_number")
);
}
}