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 TitlebarOptions, UniformListScrollHandle, Window, WindowHandle, WindowOptions, actions, div,
8 point, px, size, 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::{Divider, DropdownMenu, ListItem, Switch, prelude::*};
21use util::{paths::PathStyle, rel_path::RelPath};
22
23use crate::components::SettingsEditor;
24
25#[derive(Clone)]
26struct SettingField<T: 'static> {
27 pick: fn(&SettingsContent) -> &T,
28 pick_mut: fn(&mut SettingsContent) -> &mut T,
29}
30
31trait AnySettingField {
32 fn as_any(&self) -> &dyn Any;
33 fn type_name(&self) -> &'static str;
34 fn type_id(&self) -> TypeId;
35}
36
37impl<T> AnySettingField for SettingField<T> {
38 fn as_any(&self) -> &dyn Any {
39 self
40 }
41
42 fn type_name(&self) -> &'static str {
43 type_name::<T>()
44 }
45
46 fn type_id(&self) -> TypeId {
47 TypeId::of::<T>()
48 }
49}
50
51#[derive(Default, Clone)]
52struct SettingFieldRenderer {
53 renderers: Rc<
54 RefCell<
55 HashMap<
56 TypeId,
57 Box<
58 dyn Fn(
59 &dyn AnySettingField,
60 Option<&SettingsFieldMetadata>,
61 &mut Window,
62 &mut App,
63 ) -> AnyElement,
64 >,
65 >,
66 >,
67 >,
68}
69
70impl Global for SettingFieldRenderer {}
71
72impl SettingFieldRenderer {
73 fn add_renderer<T: 'static>(
74 &mut self,
75 renderer: impl Fn(
76 &SettingField<T>,
77 Option<&SettingsFieldMetadata>,
78 &mut Window,
79 &mut App,
80 ) -> AnyElement
81 + 'static,
82 ) -> &mut Self {
83 let key = TypeId::of::<T>();
84 let renderer = Box::new(
85 move |any_setting_field: &dyn AnySettingField,
86 metadata: Option<&SettingsFieldMetadata>,
87 window: &mut Window,
88 cx: &mut App| {
89 let field = any_setting_field
90 .as_any()
91 .downcast_ref::<SettingField<T>>()
92 .unwrap();
93 renderer(field, metadata, window, cx)
94 },
95 );
96 self.renderers.borrow_mut().insert(key, renderer);
97 self
98 }
99
100 fn render(
101 &self,
102 any_setting_field: &dyn AnySettingField,
103 metadata: Option<&SettingsFieldMetadata>,
104 window: &mut Window,
105 cx: &mut App,
106 ) -> AnyElement {
107 let key = any_setting_field.type_id();
108 if let Some(renderer) = self.renderers.borrow().get(&key) {
109 renderer(any_setting_field, metadata, window, cx)
110 } else {
111 panic!(
112 "No renderer found for type: {}",
113 any_setting_field.type_name()
114 )
115 }
116 }
117}
118
119struct SettingsFieldMetadata {
120 placeholder: Option<&'static str>,
121}
122
123fn user_settings_data() -> Vec<SettingsPage> {
124 vec![
125 SettingsPage {
126 title: "General Page",
127 expanded: true,
128 items: vec![
129 SettingsPageItem::SectionHeader("General"),
130 SettingsPageItem::SettingItem(SettingItem {
131 title: "Confirm Quit",
132 description: "Whether to confirm before quitting Zed",
133 field: Box::new(SettingField {
134 pick: |settings_content| &settings_content.workspace.confirm_quit,
135 pick_mut: |settings_content| &mut settings_content.workspace.confirm_quit,
136 }),
137 metadata: None,
138 }),
139 SettingsPageItem::SettingItem(SettingItem {
140 title: "Auto Update",
141 description: "Automatically update Zed (may be ignored on Linux if installed through a package manager)",
142 field: Box::new(SettingField {
143 pick: |settings_content| &settings_content.auto_update,
144 pick_mut: |settings_content| &mut settings_content.auto_update,
145 }),
146 metadata: None,
147 }),
148 SettingsPageItem::SectionHeader("Privacy"),
149 ],
150 },
151 SettingsPage {
152 title: "Project",
153 expanded: true,
154 items: vec![
155 SettingsPageItem::SectionHeader("Worktree Settings Content"),
156 SettingsPageItem::SettingItem(SettingItem {
157 title: "Project Name",
158 description: "The displayed name of this project. If not set, the root directory name",
159 field: Box::new(SettingField {
160 pick: |settings_content| &settings_content.project.worktree.project_name,
161 pick_mut: |settings_content| {
162 &mut settings_content.project.worktree.project_name
163 },
164 }),
165 metadata: Some(Box::new(SettingsFieldMetadata {
166 placeholder: Some("A new name"),
167 })),
168 }),
169 ],
170 },
171 SettingsPage {
172 title: "AI",
173 expanded: true,
174 items: vec![
175 SettingsPageItem::SectionHeader("General"),
176 SettingsPageItem::SettingItem(SettingItem {
177 title: "Disable AI",
178 description: "Whether to disable all AI features in Zed",
179 field: Box::new(SettingField {
180 pick: |settings_content| &settings_content.disable_ai,
181 pick_mut: |settings_content| &mut settings_content.disable_ai,
182 }),
183 metadata: None,
184 }),
185 ],
186 },
187 SettingsPage {
188 title: "Appearance & Behavior",
189 expanded: true,
190 items: vec![
191 SettingsPageItem::SectionHeader("Cursor"),
192 SettingsPageItem::SettingItem(SettingItem {
193 title: "Cursor Shape",
194 description: "Cursor shape for the editor",
195 field: Box::new(SettingField {
196 pick: |settings_content| &settings_content.editor.cursor_shape,
197 pick_mut: |settings_content| &mut settings_content.editor.cursor_shape,
198 }),
199 metadata: None,
200 }),
201 ],
202 },
203 ]
204}
205
206// Derive Macro, on the new ProjectSettings struct
207
208fn project_settings_data() -> Vec<SettingsPage> {
209 vec![SettingsPage {
210 title: "Project",
211 expanded: true,
212 items: vec![
213 SettingsPageItem::SectionHeader("Worktree Settings Content"),
214 SettingsPageItem::SettingItem(SettingItem {
215 title: "Project Name",
216 description: "The displayed name of this project. If not set, the root directory name",
217 field: Box::new(SettingField {
218 pick: |settings_content| &settings_content.project.worktree.project_name,
219 pick_mut: |settings_content| {
220 &mut settings_content.project.worktree.project_name
221 },
222 }),
223 metadata: Some(Box::new(SettingsFieldMetadata {
224 placeholder: Some("A new name"),
225 })),
226 }),
227 ],
228 }]
229}
230
231pub struct SettingsUiFeatureFlag;
232
233impl FeatureFlag for SettingsUiFeatureFlag {
234 const NAME: &'static str = "settings-ui";
235}
236
237actions!(
238 zed,
239 [
240 /// Opens Settings Editor.
241 OpenSettingsEditor
242 ]
243);
244
245pub fn init(cx: &mut App) {
246 init_renderers(cx);
247
248 cx.observe_new(|workspace: &mut workspace::Workspace, _, _| {
249 workspace.register_action_renderer(|div, _, _, cx| {
250 let settings_ui_actions = [std::any::TypeId::of::<OpenSettingsEditor>()];
251 let has_flag = cx.has_flag::<SettingsUiFeatureFlag>();
252 command_palette_hooks::CommandPaletteFilter::update_global(cx, |filter, _| {
253 if has_flag {
254 filter.show_action_types(&settings_ui_actions);
255 } else {
256 filter.hide_action_types(&settings_ui_actions);
257 }
258 });
259 if has_flag {
260 div.on_action(cx.listener(|_, _: &OpenSettingsEditor, _, cx| {
261 open_settings_editor(cx).ok();
262 }))
263 } else {
264 div
265 }
266 });
267 })
268 .detach();
269}
270
271fn init_renderers(cx: &mut App) {
272 cx.default_global::<SettingFieldRenderer>()
273 .add_renderer::<Option<bool>>(|settings_field, _, _, cx| {
274 render_toggle_button(settings_field.clone(), cx).into_any_element()
275 })
276 .add_renderer::<Option<String>>(|settings_field, metadata, _, cx| {
277 render_text_field(settings_field.clone(), metadata, cx)
278 })
279 .add_renderer::<Option<SaturatingBool>>(|settings_field, _, _, cx| {
280 render_toggle_button(settings_field.clone(), cx)
281 })
282 .add_renderer::<Option<CursorShape>>(|settings_field, _, window, cx| {
283 render_dropdown(settings_field.clone(), window, cx)
284 });
285}
286
287pub fn open_settings_editor(cx: &mut App) -> anyhow::Result<WindowHandle<SettingsWindow>> {
288 cx.open_window(
289 WindowOptions {
290 titlebar: Some(TitlebarOptions {
291 title: Some("Settings Window".into()),
292 appears_transparent: true,
293 traffic_light_position: Some(point(px(12.0), px(12.0))),
294 }),
295 focus: true,
296 show: true,
297 kind: gpui::WindowKind::Normal,
298 window_background: cx.theme().window_background_appearance(),
299 window_min_size: Some(size(px(800.), px(600.))), // 4:3 Aspect Ratio
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) => v_flex()
346 .w_full()
347 .gap_0p5()
348 .child(Label::new(SharedString::new_static(header)).size(LabelSize::Large))
349 .child(Divider::horizontal().color(ui::DividerColor::BorderVariant))
350 .into_any_element(),
351 SettingsPageItem::SettingItem(setting_item) => {
352 let renderer = cx.default_global::<SettingFieldRenderer>().clone();
353 h_flex()
354 .id(setting_item.title)
355 .w_full()
356 .gap_2()
357 .flex_wrap()
358 .justify_between()
359 .child(
360 v_flex()
361 .max_w_1_2()
362 .flex_shrink()
363 .child(
364 Label::new(SharedString::new_static(setting_item.title))
365 .size(LabelSize::Default),
366 )
367 .child(
368 Label::new(SharedString::new_static(setting_item.description))
369 .size(LabelSize::Small)
370 .color(Color::Muted),
371 ),
372 )
373 .child(renderer.render(
374 setting_item.field.as_ref(),
375 setting_item.metadata.as_deref(),
376 window,
377 cx,
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 h_flex()
530 .gap_1()
531 .children(self.files.iter().enumerate().map(|(ix, file)| {
532 Button::new(ix, file.name())
533 .on_click(cx.listener(move |this, _, _window, cx| this.change_file(ix, cx)))
534 }))
535 }
536
537 fn render_search(&self, _window: &mut Window, cx: &mut App) -> Div {
538 h_flex()
539 .pt_1()
540 .px_1p5()
541 .gap_1p5()
542 .rounded_sm()
543 .bg(cx.theme().colors().editor_background)
544 .border_1()
545 .border_color(cx.theme().colors().border)
546 .child(Icon::new(IconName::MagnifyingGlass).color(Color::Muted))
547 .child(self.search.clone())
548 }
549
550 fn render_nav(&self, window: &mut Window, cx: &mut Context<SettingsWindow>) -> Div {
551 v_flex()
552 .w_64()
553 .p_2p5()
554 .pt_10()
555 .gap_3()
556 .flex_none()
557 .border_r_1()
558 .border_color(cx.theme().colors().border)
559 .bg(cx.theme().colors().panel_background)
560 .child(self.render_search(window, cx).pb_1())
561 .child(
562 uniform_list(
563 "settings-ui-nav-bar",
564 self.navbar_entries.len(),
565 cx.processor(|this, range: Range<usize>, _, cx| {
566 range
567 .into_iter()
568 .map(|ix| {
569 let entry = &this.navbar_entries[ix];
570
571 h_flex()
572 .id(("settings-ui-section", ix))
573 .w_full()
574 .pl_2p5()
575 .py_0p5()
576 .rounded_sm()
577 .border_1()
578 .border_color(cx.theme().colors().border_transparent)
579 .text_color(cx.theme().colors().text_muted)
580 .when(this.is_navbar_entry_selected(ix), |this| {
581 this.text_color(cx.theme().colors().text)
582 .bg(cx.theme().colors().element_selected.opacity(0.2))
583 .border_color(cx.theme().colors().border)
584 })
585 .child(
586 ListItem::new(("settings-ui-navbar-entry", ix))
587 .selectable(true)
588 .inset(true)
589 .indent_step_size(px(1.))
590 .indent_level(if entry.is_root { 1 } else { 3 })
591 .when(entry.is_root, |item| {
592 item.toggle(
593 this.pages
594 [this.page_index_from_navbar_index(ix)]
595 .expanded,
596 )
597 .always_show_disclosure_icon(true)
598 .on_toggle(cx.listener(move |this, _, _, cx| {
599 this.toggle_navbar_entry(ix);
600 cx.notify();
601 }))
602 })
603 .child(
604 h_flex()
605 .text_ui(cx)
606 .truncate()
607 .hover(|s| {
608 s.bg(cx.theme().colors().element_hover)
609 })
610 .child(entry.title),
611 ),
612 )
613 .on_click(cx.listener(move |this, _, _, cx| {
614 this.navbar_entry = ix;
615 cx.notify();
616 }))
617 })
618 .collect()
619 }),
620 )
621 .track_scroll(self.list_handle.clone())
622 .size_full()
623 .flex_grow(),
624 )
625 }
626
627 fn render_page(
628 &self,
629 page: &SettingsPage,
630 window: &mut Window,
631 cx: &mut Context<SettingsWindow>,
632 ) -> Div {
633 v_flex().gap_4().children(
634 page.items
635 .iter()
636 .map(|item| item.render(self.current_file.clone(), window, cx)),
637 )
638 }
639
640 fn current_page(&self) -> &SettingsPage {
641 &self.pages[self.page_index_from_navbar_index(self.navbar_entry)]
642 }
643
644 fn page_index_from_navbar_index(&self, index: usize) -> usize {
645 self.navbar_entries
646 .iter()
647 .take(index + 1)
648 .map(|entry| entry.is_root as usize)
649 .sum::<usize>()
650 - 1
651 }
652
653 fn page_for_navbar_index(&mut self, index: usize) -> &mut SettingsPage {
654 let index = self.page_index_from_navbar_index(index);
655 &mut self.pages[index]
656 }
657
658 fn is_navbar_entry_selected(&self, ix: usize) -> bool {
659 ix == self.navbar_entry
660 }
661}
662
663impl Render for SettingsWindow {
664 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
665 div()
666 .flex()
667 .flex_row()
668 .size_full()
669 .bg(cx.theme().colors().background)
670 .text_color(cx.theme().colors().text)
671 .child(self.render_nav(window, cx))
672 .child(
673 v_flex()
674 .w_full()
675 .pt_4()
676 .px_6()
677 .gap_4()
678 .bg(cx.theme().colors().editor_background)
679 .child(self.render_files(window, cx))
680 .child(self.render_page(self.current_page(), window, cx)),
681 )
682 }
683}
684
685fn render_text_field(
686 field: SettingField<Option<String>>,
687 metadata: Option<&SettingsFieldMetadata>,
688 cx: &mut App,
689) -> AnyElement {
690 // TODO: in settings window state
691 let store = SettingsStore::global(cx);
692
693 // TODO: This clone needs to go!!
694 let defaults = store.raw_default_settings().clone();
695 let user_settings = store
696 .raw_user_settings()
697 .cloned()
698 .unwrap_or_default()
699 .content;
700
701 let initial_text = (field.pick)(&user_settings)
702 .clone()
703 .or_else(|| (field.pick)(&defaults).clone());
704
705 SettingsEditor::new()
706 .when_some(initial_text, |editor, text| editor.with_initial_text(text))
707 .when_some(
708 metadata.and_then(|metadata| metadata.placeholder),
709 |editor, placeholder| editor.with_placeholder(placeholder),
710 )
711 .on_confirm(move |new_text, cx: &mut App| {
712 cx.update_global(move |store: &mut SettingsStore, cx| {
713 store.update_settings_file(<dyn fs::Fs>::global(cx), move |settings, _cx| {
714 *(field.pick_mut)(settings) = new_text;
715 });
716 });
717 })
718 .into_any_element()
719}
720
721fn render_toggle_button<B: Into<bool> + From<bool> + Copy>(
722 field: SettingField<Option<B>>,
723 cx: &mut App,
724) -> AnyElement {
725 // TODO: in settings window state
726 let store = SettingsStore::global(cx);
727
728 // TODO: This clone needs to go!!
729 let defaults = store.raw_default_settings().clone();
730 let user_settings = store
731 .raw_user_settings()
732 .cloned()
733 .unwrap_or_default()
734 .content;
735
736 let toggle_state = if (field.pick)(&user_settings)
737 .unwrap_or_else(|| (field.pick)(&defaults).unwrap())
738 .into()
739 {
740 ui::ToggleState::Selected
741 } else {
742 ui::ToggleState::Unselected
743 };
744
745 Switch::new("toggle_button", toggle_state)
746 .on_click({
747 move |state, _window, cx| {
748 let state = *state == ui::ToggleState::Selected;
749 let field = field.clone();
750 cx.update_global(move |store: &mut SettingsStore, cx| {
751 store.update_settings_file(<dyn fs::Fs>::global(cx), move |settings, _cx| {
752 *(field.pick_mut)(settings) = Some(state.into());
753 });
754 });
755 }
756 })
757 .into_any_element()
758}
759
760fn render_dropdown<T>(
761 field: SettingField<Option<T>>,
762 window: &mut Window,
763 cx: &mut App,
764) -> AnyElement
765where
766 T: strum::VariantArray + strum::VariantNames + Copy + PartialEq + Send + 'static,
767{
768 let variants = || -> &'static [T] { <T as strum::VariantArray>::VARIANTS };
769 let labels = || -> &'static [&'static str] { <T as strum::VariantNames>::VARIANTS };
770
771 let store = SettingsStore::global(cx);
772 let defaults = store.raw_default_settings().clone();
773 let user_settings = store
774 .raw_user_settings()
775 .cloned()
776 .unwrap_or_default()
777 .content;
778
779 let current_value =
780 (field.pick)(&user_settings).unwrap_or_else(|| (field.pick)(&defaults).unwrap());
781 let current_value_label =
782 labels()[variants().iter().position(|v| *v == current_value).unwrap()];
783
784 DropdownMenu::new(
785 "dropdown",
786 current_value_label,
787 ui::ContextMenu::build(window, cx, move |mut menu, _, _| {
788 for (value, label) in variants()
789 .into_iter()
790 .copied()
791 .zip(labels().into_iter().copied())
792 {
793 menu = menu.toggleable_entry(
794 label,
795 value == current_value,
796 ui::IconPosition::Start,
797 None,
798 move |_, cx| {
799 if value == current_value {
800 return;
801 }
802 cx.update_global(move |store: &mut SettingsStore, cx| {
803 store.update_settings_file(
804 <dyn fs::Fs>::global(cx),
805 move |settings, _cx| {
806 *(field.pick_mut)(settings) = Some(value);
807 },
808 );
809 });
810 },
811 );
812 }
813 menu
814 }),
815 )
816 .into_any_element()
817}
818
819#[cfg(test)]
820mod test {
821 use super::*;
822
823 impl SettingsWindow {
824 fn navbar(&self) -> &[NavBarEntry] {
825 self.navbar_entries.as_slice()
826 }
827
828 fn navbar_entry(&self) -> usize {
829 self.navbar_entry
830 }
831 }
832
833 fn register_settings(cx: &mut App) {
834 settings::init(cx);
835 theme::init(theme::LoadThemes::JustBase, cx);
836 workspace::init_settings(cx);
837 project::Project::init_settings(cx);
838 language::init(cx);
839 editor::init(cx);
840 menu::init();
841 }
842
843 fn parse(input: &'static str, window: &mut Window, cx: &mut App) -> SettingsWindow {
844 let mut pages: Vec<SettingsPage> = Vec::new();
845 let mut current_page = None;
846 let mut selected_idx = None;
847
848 for (ix, mut line) in input
849 .lines()
850 .map(|line| line.trim())
851 .filter(|line| !line.is_empty())
852 .enumerate()
853 {
854 if line.ends_with("*") {
855 assert!(
856 selected_idx.is_none(),
857 "Can only have one selected navbar entry at a time"
858 );
859 selected_idx = Some(ix);
860 line = &line[..line.len() - 1];
861 }
862
863 if line.starts_with("v") || line.starts_with(">") {
864 if let Some(current_page) = current_page.take() {
865 pages.push(current_page);
866 }
867
868 let expanded = line.starts_with("v");
869
870 current_page = Some(SettingsPage {
871 title: line.split_once(" ").unwrap().1,
872 expanded,
873 items: Vec::default(),
874 });
875 } else if line.starts_with("-") {
876 let Some(current_page) = current_page.as_mut() else {
877 panic!("Sub entries must be within a page");
878 };
879
880 current_page.items.push(SettingsPageItem::SectionHeader(
881 line.split_once(" ").unwrap().1,
882 ));
883 } else {
884 panic!(
885 "Entries must start with one of 'v', '>', or '-'\n line: {}",
886 line
887 );
888 }
889 }
890
891 if let Some(current_page) = current_page.take() {
892 pages.push(current_page);
893 }
894
895 let mut settings_window = SettingsWindow {
896 files: Vec::default(),
897 current_file: crate::SettingsFile::User,
898 pages,
899 search: cx.new(|cx| Editor::single_line(window, cx)),
900 navbar_entry: selected_idx.unwrap(),
901 navbar_entries: Vec::default(),
902 list_handle: UniformListScrollHandle::default(),
903 };
904
905 settings_window.build_navbar();
906 settings_window
907 }
908
909 #[track_caller]
910 fn check_navbar_toggle(
911 before: &'static str,
912 toggle_idx: usize,
913 after: &'static str,
914 window: &mut Window,
915 cx: &mut App,
916 ) {
917 let mut settings_window = parse(before, window, cx);
918 settings_window.toggle_navbar_entry(toggle_idx);
919
920 let expected_settings_window = parse(after, window, cx);
921
922 assert_eq!(settings_window.navbar(), expected_settings_window.navbar());
923 assert_eq!(
924 settings_window.navbar_entry(),
925 expected_settings_window.navbar_entry()
926 );
927 }
928
929 macro_rules! check_navbar_toggle {
930 ($name:ident, before: $before:expr, toggle_idx: $toggle_idx:expr, after: $after:expr) => {
931 #[gpui::test]
932 fn $name(cx: &mut gpui::TestAppContext) {
933 let window = cx.add_empty_window();
934 window.update(|window, cx| {
935 register_settings(cx);
936 check_navbar_toggle($before, $toggle_idx, $after, window, cx);
937 });
938 }
939 };
940 }
941
942 check_navbar_toggle!(
943 basic_open,
944 before: r"
945 v General
946 - General
947 - Privacy*
948 v Project
949 - Project Settings
950 ",
951 toggle_idx: 0,
952 after: r"
953 > General*
954 v Project
955 - Project Settings
956 "
957 );
958
959 check_navbar_toggle!(
960 basic_close,
961 before: r"
962 > General*
963 - General
964 - Privacy
965 v Project
966 - Project Settings
967 ",
968 toggle_idx: 0,
969 after: r"
970 v General*
971 - General
972 - Privacy
973 v Project
974 - Project Settings
975 "
976 );
977
978 check_navbar_toggle!(
979 basic_second_root_entry_close,
980 before: r"
981 > General
982 - General
983 - Privacy
984 v Project
985 - Project Settings*
986 ",
987 toggle_idx: 1,
988 after: r"
989 > General
990 > Project*
991 "
992 );
993}