1//! # settings_ui
2mod components;
3use editor::Editor;
4use feature_flags::{FeatureFlag, FeatureFlagAppExt as _};
5use gpui::{
6 App, AppContext as _, Context, Div, Entity, Global, IntoElement, ReadGlobal as _, Render,
7 UniformListScrollHandle, Window, WindowHandle, WindowOptions, actions, div, px, size,
8 uniform_list,
9};
10use project::WorktreeId;
11use settings::{CursorShape, SaturatingBool, SettingsContent, SettingsStore};
12use std::{
13 any::{Any, TypeId, type_name},
14 cell::RefCell,
15 collections::HashMap,
16 ops::Range,
17 rc::Rc,
18 sync::Arc,
19};
20use ui::{
21 ActiveTheme as _, AnyElement, BorrowAppContext as _, Button, Clickable as _, Color, Divider,
22 DropdownMenu, FluentBuilder as _, Icon, IconName, InteractiveElement as _, Label,
23 LabelCommon as _, LabelSize, ListItem, ParentElement, SharedString,
24 StatefulInteractiveElement as _, Styled, StyledTypography, Switch, h_flex, v_flex,
25};
26use util::{paths::PathStyle, rel_path::RelPath};
27
28use crate::components::SettingsEditor;
29
30#[derive(Clone)]
31struct SettingField<T: 'static> {
32 pick: fn(&SettingsContent) -> &T,
33 pick_mut: fn(&mut SettingsContent) -> &mut T,
34}
35
36trait AnySettingField {
37 fn as_any(&self) -> &dyn Any;
38 fn type_name(&self) -> &'static str;
39 fn type_id(&self) -> TypeId;
40}
41
42impl<T> AnySettingField for SettingField<T> {
43 fn as_any(&self) -> &dyn Any {
44 self
45 }
46
47 fn type_name(&self) -> &'static str {
48 type_name::<T>()
49 }
50
51 fn type_id(&self) -> TypeId {
52 TypeId::of::<T>()
53 }
54}
55
56#[derive(Default, Clone)]
57struct SettingFieldRenderer {
58 renderers: Rc<
59 RefCell<
60 HashMap<
61 TypeId,
62 Box<
63 dyn Fn(
64 &dyn AnySettingField,
65 Option<&SettingsFieldMetadata>,
66 &mut Window,
67 &mut App,
68 ) -> AnyElement,
69 >,
70 >,
71 >,
72 >,
73}
74
75impl Global for SettingFieldRenderer {}
76
77impl SettingFieldRenderer {
78 fn add_renderer<T: 'static>(
79 &mut self,
80 renderer: impl Fn(
81 &SettingField<T>,
82 Option<&SettingsFieldMetadata>,
83 &mut Window,
84 &mut App,
85 ) -> AnyElement
86 + 'static,
87 ) -> &mut Self {
88 let key = TypeId::of::<T>();
89 let renderer = Box::new(
90 move |any_setting_field: &dyn AnySettingField,
91 metadata: Option<&SettingsFieldMetadata>,
92 window: &mut Window,
93 cx: &mut App| {
94 let field = any_setting_field
95 .as_any()
96 .downcast_ref::<SettingField<T>>()
97 .unwrap();
98 renderer(field, metadata, window, cx)
99 },
100 );
101 self.renderers.borrow_mut().insert(key, renderer);
102 self
103 }
104
105 fn render(
106 &self,
107 any_setting_field: &dyn AnySettingField,
108 metadata: Option<&SettingsFieldMetadata>,
109 window: &mut Window,
110 cx: &mut App,
111 ) -> AnyElement {
112 let key = any_setting_field.type_id();
113 if let Some(renderer) = self.renderers.borrow().get(&key) {
114 renderer(any_setting_field, metadata, window, cx)
115 } else {
116 panic!(
117 "No renderer found for type: {}",
118 any_setting_field.type_name()
119 )
120 }
121 }
122}
123
124struct SettingsFieldMetadata {
125 placeholder: Option<&'static str>,
126}
127
128fn user_settings_data() -> Vec<SettingsPage> {
129 vec![
130 SettingsPage {
131 title: "General Page",
132 expanded: true,
133 items: vec![
134 SettingsPageItem::SectionHeader("General"),
135 SettingsPageItem::SettingItem(SettingItem {
136 title: "Confirm Quit",
137 description: "Whether to confirm before quitting Zed",
138 field: Box::new(SettingField {
139 pick: |settings_content| &settings_content.workspace.confirm_quit,
140 pick_mut: |settings_content| &mut settings_content.workspace.confirm_quit,
141 }),
142 metadata: None,
143 }),
144 SettingsPageItem::SettingItem(SettingItem {
145 title: "Auto Update",
146 description: "Automatically update Zed (may be ignored on Linux if installed through a package manager)",
147 field: Box::new(SettingField {
148 pick: |settings_content| &settings_content.auto_update,
149 pick_mut: |settings_content| &mut settings_content.auto_update,
150 }),
151 metadata: None,
152 }),
153 SettingsPageItem::SectionHeader("Privacy"),
154 ],
155 },
156 SettingsPage {
157 title: "Project",
158 expanded: true,
159 items: vec![
160 SettingsPageItem::SectionHeader("Worktree Settings Content"),
161 SettingsPageItem::SettingItem(SettingItem {
162 title: "Project Name",
163 description: "The displayed name of this project. If not set, the root directory name",
164 field: Box::new(SettingField {
165 pick: |settings_content| &settings_content.project.worktree.project_name,
166 pick_mut: |settings_content| {
167 &mut settings_content.project.worktree.project_name
168 },
169 }),
170 metadata: Some(Box::new(SettingsFieldMetadata {
171 placeholder: Some("A new name"),
172 })),
173 }),
174 ],
175 },
176 SettingsPage {
177 title: "AI",
178 expanded: true,
179 items: vec![
180 SettingsPageItem::SectionHeader("General"),
181 SettingsPageItem::SettingItem(SettingItem {
182 title: "Disable AI",
183 description: "Whether to disable all AI features in Zed",
184 field: Box::new(SettingField {
185 pick: |settings_content| &settings_content.disable_ai,
186 pick_mut: |settings_content| &mut settings_content.disable_ai,
187 }),
188 metadata: None,
189 }),
190 ],
191 },
192 SettingsPage {
193 title: "Appearance & Behavior",
194 expanded: true,
195 items: vec![
196 SettingsPageItem::SectionHeader("Cursor"),
197 SettingsPageItem::SettingItem(SettingItem {
198 title: "Cursor Shape",
199 description: "Cursor shape for the editor",
200 field: Box::new(SettingField {
201 pick: |settings_content| &settings_content.editor.cursor_shape,
202 pick_mut: |settings_content| &mut settings_content.editor.cursor_shape,
203 }),
204 metadata: None,
205 }),
206 ],
207 },
208 ]
209}
210
211// Derive Macro, on the new ProjectSettings struct
212
213fn project_settings_data() -> Vec<SettingsPage> {
214 vec![SettingsPage {
215 title: "Project",
216 expanded: true,
217 items: vec![
218 SettingsPageItem::SectionHeader("Worktree Settings Content"),
219 SettingsPageItem::SettingItem(SettingItem {
220 title: "Project Name",
221 description: "The displayed name of this project. If not set, the root directory name",
222 field: Box::new(SettingField {
223 pick: |settings_content| &settings_content.project.worktree.project_name,
224 pick_mut: |settings_content| {
225 &mut settings_content.project.worktree.project_name
226 },
227 }),
228 metadata: Some(Box::new(SettingsFieldMetadata {
229 placeholder: Some("A new name"),
230 })),
231 }),
232 ],
233 }]
234}
235
236pub struct SettingsUiFeatureFlag;
237
238impl FeatureFlag for SettingsUiFeatureFlag {
239 const NAME: &'static str = "settings-ui";
240}
241
242actions!(
243 zed,
244 [
245 /// Opens Settings Editor.
246 OpenSettingsEditor
247 ]
248);
249
250pub fn init(cx: &mut App) {
251 init_renderers(cx);
252
253 cx.observe_new(|workspace: &mut workspace::Workspace, _, _| {
254 workspace.register_action_renderer(|div, _, _, cx| {
255 let settings_ui_actions = [std::any::TypeId::of::<OpenSettingsEditor>()];
256 let has_flag = cx.has_flag::<SettingsUiFeatureFlag>();
257 command_palette_hooks::CommandPaletteFilter::update_global(cx, |filter, _| {
258 if has_flag {
259 filter.show_action_types(&settings_ui_actions);
260 } else {
261 filter.hide_action_types(&settings_ui_actions);
262 }
263 });
264 if has_flag {
265 div.on_action(cx.listener(|_, _: &OpenSettingsEditor, _, cx| {
266 open_settings_editor(cx).ok();
267 }))
268 } else {
269 div
270 }
271 });
272 })
273 .detach();
274}
275
276fn init_renderers(cx: &mut App) {
277 cx.default_global::<SettingFieldRenderer>()
278 .add_renderer::<Option<bool>>(|settings_field, _, _, cx| {
279 render_toggle_button(settings_field.clone(), cx).into_any_element()
280 })
281 .add_renderer::<Option<String>>(|settings_field, metadata, _, cx| {
282 render_text_field(settings_field.clone(), metadata, cx)
283 })
284 .add_renderer::<Option<SaturatingBool>>(|settings_field, _, _, cx| {
285 render_toggle_button(settings_field.clone(), cx)
286 })
287 .add_renderer::<Option<CursorShape>>(|settings_field, _, window, cx| {
288 render_dropdown(settings_field.clone(), window, cx)
289 });
290}
291
292pub fn open_settings_editor(cx: &mut App) -> anyhow::Result<WindowHandle<SettingsWindow>> {
293 cx.open_window(
294 WindowOptions {
295 titlebar: None,
296 focus: true,
297 show: true,
298 kind: gpui::WindowKind::Normal,
299 window_min_size: Some(size(px(300.), px(500.))), // todo(settings_ui): Does this min_size make sense?
300 ..Default::default()
301 },
302 |window, cx| cx.new(|cx| SettingsWindow::new(window, cx)),
303 )
304}
305
306pub struct SettingsWindow {
307 files: Vec<SettingsFile>,
308 current_file: SettingsFile,
309 pages: Vec<SettingsPage>,
310 search: Entity<Editor>,
311 navbar_entry: usize, // Index into pages - should probably be (usize, Option<usize>) for section + page
312 navbar_entries: Vec<NavBarEntry>,
313 list_handle: UniformListScrollHandle,
314}
315
316#[derive(PartialEq, Debug)]
317struct NavBarEntry {
318 title: &'static str,
319 is_root: bool,
320}
321
322struct SettingsPage {
323 title: &'static str,
324 expanded: bool,
325 items: Vec<SettingsPageItem>,
326}
327
328impl SettingsPage {
329 fn section_headers(&self) -> impl Iterator<Item = &'static str> {
330 self.items.iter().filter_map(|item| match item {
331 SettingsPageItem::SectionHeader(header) => Some(*header),
332 _ => None,
333 })
334 }
335}
336
337enum SettingsPageItem {
338 SectionHeader(&'static str),
339 SettingItem(SettingItem),
340}
341
342impl SettingsPageItem {
343 fn render(&self, _file: SettingsFile, window: &mut Window, cx: &mut App) -> AnyElement {
344 match self {
345 SettingsPageItem::SectionHeader(header) => div()
346 .w_full()
347 .child(Label::new(SharedString::new_static(header)).size(LabelSize::Large))
348 .child(Divider::horizontal().color(ui::DividerColor::BorderVariant))
349 .into_any_element(),
350 SettingsPageItem::SettingItem(setting_item) => {
351 let renderer = cx.default_global::<SettingFieldRenderer>().clone();
352 div()
353 .id(setting_item.title)
354 .child(
355 Label::new(SharedString::new_static(setting_item.title))
356 .size(LabelSize::Default),
357 )
358 .child(
359 h_flex()
360 .justify_between()
361 .child(
362 div()
363 .child(
364 Label::new(SharedString::new_static(
365 setting_item.description,
366 ))
367 .size(LabelSize::Small)
368 .color(Color::Muted),
369 )
370 .max_w_1_2(),
371 )
372 .child(renderer.render(
373 setting_item.field.as_ref(),
374 setting_item.metadata.as_deref(),
375 window,
376 cx,
377 )),
378 )
379 .into_any_element()
380 }
381 }
382 }
383}
384
385struct SettingItem {
386 title: &'static str,
387 description: &'static str,
388 field: Box<dyn AnySettingField>,
389 metadata: Option<Box<SettingsFieldMetadata>>,
390}
391
392#[allow(unused)]
393#[derive(Clone, PartialEq)]
394enum SettingsFile {
395 User, // Uses all settings.
396 Local((WorktreeId, Arc<RelPath>)), // Has a special name, and special set of settings
397 Server(&'static str), // Uses a special name, and the user settings
398}
399
400impl SettingsFile {
401 fn pages(&self) -> Vec<SettingsPage> {
402 match self {
403 SettingsFile::User => user_settings_data(),
404 SettingsFile::Local(_) => project_settings_data(),
405 SettingsFile::Server(_) => user_settings_data(),
406 }
407 }
408
409 fn name(&self) -> SharedString {
410 match self {
411 SettingsFile::User => SharedString::new_static("User"),
412 // TODO is PathStyle::local() ever not appropriate?
413 SettingsFile::Local((_, path)) => {
414 format!("Local ({})", path.display(PathStyle::local())).into()
415 }
416 SettingsFile::Server(file) => format!("Server ({})", file).into(),
417 }
418 }
419}
420
421impl SettingsWindow {
422 pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
423 let current_file = SettingsFile::User;
424 let search = cx.new(|cx| {
425 let mut editor = Editor::single_line(window, cx);
426 editor.set_placeholder_text("Search Settings", window, cx);
427 editor
428 });
429 let mut this = Self {
430 files: vec![],
431 current_file: current_file,
432 pages: vec![],
433 navbar_entries: vec![],
434 navbar_entry: 0,
435 list_handle: UniformListScrollHandle::default(),
436 search,
437 };
438 cx.observe_global_in::<SettingsStore>(window, move |this, _, cx| {
439 this.fetch_files(cx);
440 cx.notify();
441 })
442 .detach();
443 this.fetch_files(cx);
444
445 this.build_ui(cx);
446 this
447 }
448
449 fn toggle_navbar_entry(&mut self, ix: usize) {
450 if self.navbar_entries[ix].is_root {
451 let expanded = &mut self.page_for_navbar_index(ix).expanded;
452 *expanded = !*expanded;
453 let current_page_index = self.page_index_from_navbar_index(self.navbar_entry);
454 // if currently selected page is a child of the parent page we are folding,
455 // set the current page to the parent page
456 if current_page_index == ix {
457 self.navbar_entry = ix;
458 }
459 self.build_navbar();
460 }
461 }
462
463 fn build_navbar(&mut self) {
464 self.navbar_entries = self
465 .pages
466 .iter()
467 .flat_map(|page| {
468 std::iter::once(NavBarEntry {
469 title: page.title,
470 is_root: true,
471 })
472 .chain(
473 page.expanded
474 .then(|| {
475 page.section_headers().map(|h| NavBarEntry {
476 title: h,
477 is_root: false,
478 })
479 })
480 .into_iter()
481 .flatten(),
482 )
483 })
484 .collect();
485 }
486
487 fn build_ui(&mut self, cx: &mut Context<SettingsWindow>) {
488 self.pages = self.current_file.pages();
489 self.build_navbar();
490
491 cx.notify();
492 }
493
494 fn fetch_files(&mut self, cx: &mut Context<SettingsWindow>) {
495 let settings_store = cx.global::<SettingsStore>();
496 let mut ui_files = vec![];
497 let all_files = settings_store.get_all_files();
498 for file in all_files {
499 let settings_ui_file = match file {
500 settings::SettingsFile::User => SettingsFile::User,
501 settings::SettingsFile::Global => continue,
502 settings::SettingsFile::Extension => continue,
503 settings::SettingsFile::Server => SettingsFile::Server("todo: server name"),
504 settings::SettingsFile::Default => continue,
505 settings::SettingsFile::Local(location) => SettingsFile::Local(location),
506 };
507 ui_files.push(settings_ui_file);
508 }
509 ui_files.reverse();
510 if !ui_files.contains(&self.current_file) {
511 self.change_file(0, cx);
512 }
513 self.files = ui_files;
514 }
515
516 fn change_file(&mut self, ix: usize, cx: &mut Context<SettingsWindow>) {
517 if ix >= self.files.len() {
518 self.current_file = SettingsFile::User;
519 return;
520 }
521 if self.files[ix] == self.current_file {
522 return;
523 }
524 self.current_file = self.files[ix].clone();
525 self.build_ui(cx);
526 }
527
528 fn render_files(&self, _window: &mut Window, cx: &mut Context<SettingsWindow>) -> Div {
529 div()
530 .flex()
531 .flex_row()
532 .gap_1()
533 .children(self.files.iter().enumerate().map(|(ix, file)| {
534 Button::new(ix, file.name())
535 .on_click(cx.listener(move |this, _, _window, cx| this.change_file(ix, cx)))
536 }))
537 }
538
539 fn render_search(&self, _window: &mut Window, _cx: &mut App) -> Div {
540 h_flex()
541 .child(Icon::new(IconName::MagnifyingGlass))
542 .child(self.search.clone())
543 }
544
545 fn render_nav(&self, window: &mut Window, cx: &mut Context<SettingsWindow>) -> Div {
546 v_flex()
547 .bg(cx.theme().colors().panel_background)
548 .p_3()
549 .child(div().h_10()) // Files spacer;
550 .child(self.render_search(window, cx).pb_1())
551 .gap_3()
552 .child(
553 uniform_list(
554 "settings-ui-nav-bar",
555 self.navbar_entries.len(),
556 cx.processor(|this, range: Range<usize>, _, cx| {
557 range
558 .into_iter()
559 .map(|ix| {
560 let entry = &this.navbar_entries[ix];
561
562 div()
563 .id(("settings-ui-section", ix))
564 .child(
565 ListItem::new(("settings-ui-navbar-entry", ix))
566 .selectable(true)
567 .indent_step_size(px(10.))
568 .indent_level(if entry.is_root { 1 } else { 3 })
569 .when(entry.is_root, |item| {
570 item.toggle(
571 this.pages
572 [this.page_index_from_navbar_index(ix)]
573 .expanded,
574 )
575 .always_show_disclosure_icon(true)
576 .on_toggle(cx.listener(move |this, _, _, cx| {
577 this.toggle_navbar_entry(ix);
578 cx.notify();
579 }))
580 })
581 .child(
582 div()
583 .text_ui(cx)
584 .size_full()
585 .child(entry.title)
586 .hover(|style| {
587 style.bg(cx.theme().colors().element_hover)
588 })
589 .when(!entry.is_root, |this| {
590 this.text_color(
591 cx.theme().colors().text_muted,
592 )
593 })
594 .when(
595 this.is_navbar_entry_selected(ix),
596 |this| {
597 this.text_color(
598 Color::Selected.color(cx),
599 )
600 },
601 ),
602 ),
603 )
604 .on_click(cx.listener(move |this, _, _, cx| {
605 this.navbar_entry = ix;
606 cx.notify();
607 }))
608 })
609 .collect()
610 }),
611 )
612 .track_scroll(self.list_handle.clone())
613 .gap_1_5()
614 .size_full()
615 .flex_grow(),
616 )
617 }
618
619 fn render_page(
620 &self,
621 page: &SettingsPage,
622 window: &mut Window,
623 cx: &mut Context<SettingsWindow>,
624 ) -> Div {
625 v_flex().gap_4().py_4().children(
626 page.items
627 .iter()
628 .map(|item| item.render(self.current_file.clone(), window, cx)),
629 )
630 }
631
632 fn current_page(&self) -> &SettingsPage {
633 &self.pages[self.page_index_from_navbar_index(self.navbar_entry)]
634 }
635
636 fn page_index_from_navbar_index(&self, index: usize) -> usize {
637 self.navbar_entries
638 .iter()
639 .take(index + 1)
640 .map(|entry| entry.is_root as usize)
641 .sum::<usize>()
642 - 1
643 }
644
645 fn page_for_navbar_index(&mut self, index: usize) -> &mut SettingsPage {
646 let index = self.page_index_from_navbar_index(index);
647 &mut self.pages[index]
648 }
649
650 fn is_navbar_entry_selected(&self, ix: usize) -> bool {
651 ix == self.navbar_entry
652 }
653}
654
655impl Render for SettingsWindow {
656 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
657 div()
658 .size_full()
659 .bg(cx.theme().colors().background)
660 .flex()
661 .flex_row()
662 .text_color(cx.theme().colors().text)
663 .child(self.render_nav(window, cx).w(px(300.0)))
664 .child(Divider::vertical().color(ui::DividerColor::BorderVariant))
665 .child(
666 v_flex()
667 .bg(cx.theme().colors().editor_background)
668 .px_6()
669 .py_2()
670 .child(self.render_files(window, cx))
671 .child(self.render_page(self.current_page(), window, cx))
672 .w_full(),
673 )
674 }
675}
676
677fn render_text_field(
678 field: SettingField<Option<String>>,
679 metadata: Option<&SettingsFieldMetadata>,
680 cx: &mut App,
681) -> AnyElement {
682 // TODO: in settings window state
683 let store = SettingsStore::global(cx);
684
685 // TODO: This clone needs to go!!
686 let defaults = store.raw_default_settings().clone();
687 let user_settings = store
688 .raw_user_settings()
689 .cloned()
690 .unwrap_or_default()
691 .content;
692
693 let initial_text = (field.pick)(&user_settings)
694 .clone()
695 .or_else(|| (field.pick)(&defaults).clone());
696
697 SettingsEditor::new()
698 .when_some(initial_text, |editor, text| editor.with_initial_text(text))
699 .when_some(
700 metadata.and_then(|metadata| metadata.placeholder),
701 |editor, placeholder| editor.with_placeholder(placeholder),
702 )
703 .on_confirm(move |new_text, cx: &mut App| {
704 cx.update_global(move |store: &mut SettingsStore, cx| {
705 store.update_settings_file(<dyn fs::Fs>::global(cx), move |settings, _cx| {
706 *(field.pick_mut)(settings) = new_text;
707 });
708 });
709 })
710 .into_any_element()
711}
712
713fn render_toggle_button<B: Into<bool> + From<bool> + Copy>(
714 field: SettingField<Option<B>>,
715 cx: &mut App,
716) -> AnyElement {
717 // TODO: in settings window state
718 let store = SettingsStore::global(cx);
719
720 // TODO: This clone needs to go!!
721 let defaults = store.raw_default_settings().clone();
722 let user_settings = store
723 .raw_user_settings()
724 .cloned()
725 .unwrap_or_default()
726 .content;
727
728 let toggle_state = if (field.pick)(&user_settings)
729 .unwrap_or_else(|| (field.pick)(&defaults).unwrap())
730 .into()
731 {
732 ui::ToggleState::Selected
733 } else {
734 ui::ToggleState::Unselected
735 };
736
737 Switch::new("toggle_button", toggle_state)
738 .on_click({
739 move |state, _window, cx| {
740 let state = *state == ui::ToggleState::Selected;
741 let field = field.clone();
742 cx.update_global(move |store: &mut SettingsStore, cx| {
743 store.update_settings_file(<dyn fs::Fs>::global(cx), move |settings, _cx| {
744 *(field.pick_mut)(settings) = Some(state.into());
745 });
746 });
747 }
748 })
749 .into_any_element()
750}
751
752fn render_dropdown<T>(
753 field: SettingField<Option<T>>,
754 window: &mut Window,
755 cx: &mut App,
756) -> AnyElement
757where
758 T: strum::VariantArray + strum::VariantNames + Copy + PartialEq + Send + 'static,
759{
760 let variants = || -> &'static [T] { <T as strum::VariantArray>::VARIANTS };
761 let labels = || -> &'static [&'static str] { <T as strum::VariantNames>::VARIANTS };
762
763 let store = SettingsStore::global(cx);
764 let defaults = store.raw_default_settings().clone();
765 let user_settings = store
766 .raw_user_settings()
767 .cloned()
768 .unwrap_or_default()
769 .content;
770
771 let current_value =
772 (field.pick)(&user_settings).unwrap_or_else(|| (field.pick)(&defaults).unwrap());
773 let current_value_label =
774 labels()[variants().iter().position(|v| *v == current_value).unwrap()];
775
776 DropdownMenu::new(
777 "dropdown",
778 current_value_label,
779 ui::ContextMenu::build(window, cx, move |mut menu, _, _| {
780 for (value, label) in variants()
781 .into_iter()
782 .copied()
783 .zip(labels().into_iter().copied())
784 {
785 menu = menu.toggleable_entry(
786 label,
787 value == current_value,
788 ui::IconPosition::Start,
789 None,
790 move |_, cx| {
791 if value == current_value {
792 return;
793 }
794 cx.update_global(move |store: &mut SettingsStore, cx| {
795 store.update_settings_file(
796 <dyn fs::Fs>::global(cx),
797 move |settings, _cx| {
798 *(field.pick_mut)(settings) = Some(value);
799 },
800 );
801 });
802 },
803 );
804 }
805 menu
806 }),
807 )
808 .into_any_element()
809}
810
811#[cfg(test)]
812mod test {
813 use super::*;
814
815 impl SettingsWindow {
816 fn navbar(&self) -> &[NavBarEntry] {
817 self.navbar_entries.as_slice()
818 }
819
820 fn navbar_entry(&self) -> usize {
821 self.navbar_entry
822 }
823 }
824
825 fn register_settings(cx: &mut App) {
826 settings::init(cx);
827 theme::init(theme::LoadThemes::JustBase, cx);
828 workspace::init_settings(cx);
829 project::Project::init_settings(cx);
830 language::init(cx);
831 editor::init(cx);
832 menu::init();
833 }
834
835 fn parse(input: &'static str, window: &mut Window, cx: &mut App) -> SettingsWindow {
836 let mut pages: Vec<SettingsPage> = Vec::new();
837 let mut current_page = None;
838 let mut selected_idx = None;
839
840 for (ix, mut line) in input
841 .lines()
842 .map(|line| line.trim())
843 .filter(|line| !line.is_empty())
844 .enumerate()
845 {
846 if line.ends_with("*") {
847 assert!(
848 selected_idx.is_none(),
849 "Can only have one selected navbar entry at a time"
850 );
851 selected_idx = Some(ix);
852 line = &line[..line.len() - 1];
853 }
854
855 if line.starts_with("v") || line.starts_with(">") {
856 if let Some(current_page) = current_page.take() {
857 pages.push(current_page);
858 }
859
860 let expanded = line.starts_with("v");
861
862 current_page = Some(SettingsPage {
863 title: line.split_once(" ").unwrap().1,
864 expanded,
865 items: Vec::default(),
866 });
867 } else if line.starts_with("-") {
868 let Some(current_page) = current_page.as_mut() else {
869 panic!("Sub entries must be within a page");
870 };
871
872 current_page.items.push(SettingsPageItem::SectionHeader(
873 line.split_once(" ").unwrap().1,
874 ));
875 } else {
876 panic!(
877 "Entries must start with one of 'v', '>', or '-'\n line: {}",
878 line
879 );
880 }
881 }
882
883 if let Some(current_page) = current_page.take() {
884 pages.push(current_page);
885 }
886
887 let mut settings_window = SettingsWindow {
888 files: Vec::default(),
889 current_file: crate::SettingsFile::User,
890 pages,
891 search: cx.new(|cx| Editor::single_line(window, cx)),
892 navbar_entry: selected_idx.unwrap(),
893 navbar_entries: Vec::default(),
894 list_handle: UniformListScrollHandle::default(),
895 };
896
897 settings_window.build_navbar();
898 settings_window
899 }
900
901 #[track_caller]
902 fn check_navbar_toggle(
903 before: &'static str,
904 toggle_idx: usize,
905 after: &'static str,
906 window: &mut Window,
907 cx: &mut App,
908 ) {
909 let mut settings_window = parse(before, window, cx);
910 settings_window.toggle_navbar_entry(toggle_idx);
911
912 let expected_settings_window = parse(after, window, cx);
913
914 assert_eq!(settings_window.navbar(), expected_settings_window.navbar());
915 assert_eq!(
916 settings_window.navbar_entry(),
917 expected_settings_window.navbar_entry()
918 );
919 }
920
921 macro_rules! check_navbar_toggle {
922 ($name:ident, before: $before:expr, toggle_idx: $toggle_idx:expr, after: $after:expr) => {
923 #[gpui::test]
924 fn $name(cx: &mut gpui::TestAppContext) {
925 let window = cx.add_empty_window();
926 window.update(|window, cx| {
927 register_settings(cx);
928 check_navbar_toggle($before, $toggle_idx, $after, window, cx);
929 });
930 }
931 };
932 }
933
934 check_navbar_toggle!(
935 basic_open,
936 before: r"
937 v General
938 - General
939 - Privacy*
940 v Project
941 - Project Settings
942 ",
943 toggle_idx: 0,
944 after: r"
945 > General*
946 v Project
947 - Project Settings
948 "
949 );
950
951 check_navbar_toggle!(
952 basic_close,
953 before: r"
954 > General*
955 - General
956 - Privacy
957 v Project
958 - Project Settings
959 ",
960 toggle_idx: 0,
961 after: r"
962 v General*
963 - General
964 - Privacy
965 v Project
966 - Project Settings
967 "
968 );
969
970 check_navbar_toggle!(
971 basic_second_root_entry_close,
972 before: r"
973 > General
974 - General
975 - Privacy
976 v Project
977 - Project Settings*
978 ",
979 toggle_idx: 1,
980 after: r"
981 > General
982 > Project*
983 "
984 );
985}