Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

markdown_preview: Group settings and add automatic preview opening (#63462)

Josh Kentc1eda3e88aff
diff --git a/assets/settings/default.json b/assets/settings/default.json
index 38ba01b3883..439e82943f0 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -79,12 +79,6 @@
"agent_buffer_font_size": 12,
// The default font size for the commit editor in the git panel and commit modal.
"git_commit_buffer_font_size": 12,
- // The default font size for the markdown preview. Falls back to the UI font size if unset.
- "markdown_preview_font_size": null,
- // The font family for the markdown preview. Falls back to the UI font family if unset.
- "markdown_preview_font_family": null,
- // The font family for code blocks in the markdown preview. Falls back to the editor font family if unset.
- "markdown_preview_code_font_family": null,
// How much to fade out unused code.
"unnecessary_code_fade": 0.3,
// Active pane styling settings.
@@ -118,6 +112,14 @@
},
// Markdown preview settings
"markdown_preview": {
+ // The default font size for the markdown preview. Falls back to the UI font size if unset.
+ "font_size": null,
+ // The font family for the markdown preview. Falls back to the UI font family if unset.
+ "font_family": null,
+ // The font family for code blocks in the markdown preview. Falls back to the editor font family if unset.
+ "code_font_family": null,
+ // Whether to automatically open Markdown files in the preview.
+ "open_markdown_files_in_preview": false,
// Whether to limit the width of the rendered markdown content. When
// enabled, content is constrained to `max_width` and centered
// horizontally within the preview pane.
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 95e17cf30ce..c8f10d3117b 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -6836,7 +6836,7 @@ mod tests {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
settings.theme.ui_font_size = Some(16.0.into());
- settings.theme.markdown_preview_font_size = None;
+ settings.markdown_preview.get_or_insert_default().font_size = None;
});
});
});
@@ -6864,7 +6864,7 @@ mod tests {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
settings.theme.ui_font_size = Some(20.0.into());
- settings.theme.markdown_preview_font_size = None;
+ settings.markdown_preview.get_or_insert_default().font_size = None;
});
});
});
@@ -6925,7 +6925,7 @@ mod tests {
cx.update(|cx| {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
- settings.theme.markdown_preview_font_size = Some(14.0.into());
+ settings.markdown_preview.get_or_insert_default().font_size = Some(14.0.into());
settings.theme.buffer_line_height =
Some(settings::BufferLineHeight::Custom(1.5));
});
@@ -7130,7 +7130,7 @@ mod tests {
/// Note that this does not reproduce the `WithRemSize` wrapper the real
/// preview renders inside, so rem-derived lengths (such as the `rems(1.3)`
/// prose leading) resolve against the default rem size rather than
- /// `markdown_preview_font_size`. Code block metrics are unaffected, since
+ /// `markdown_preview.font_size`. Code block metrics are unaffected, since
/// the code font size is set as absolute pixels.
fn rendered_prose_and_code_line_heights(
cx: &mut TestAppContext,
@@ -7141,7 +7141,8 @@ mod tests {
cx.update(|cx| {
settings::SettingsStore::update_global(cx, |store, cx| {
store.update_user_settings(cx, |settings| {
- settings.theme.markdown_preview_font_size = Some(font_size.into());
+ settings.markdown_preview.get_or_insert_default().font_size =
+ Some(font_size.into());
settings.theme.buffer_line_height =
Some(settings::BufferLineHeight::Custom(buffer_line_height));
});
diff --git a/crates/markdown_preview/Cargo.toml b/crates/markdown_preview/Cargo.toml
index 69addd9034e..662b3b95ff3 100644
--- a/crates/markdown_preview/Cargo.toml
+++ b/crates/markdown_preview/Cargo.toml
@@ -34,6 +34,7 @@ zed_actions.workspace = true
[dev-dependencies]
buffer_diff.workspace = true
+db = { workspace = true, features = ["test-support"] }
editor = { workspace = true, features = ["test-support"] }
fs.workspace = true
gpui = { workspace = true, features = ["test-support"] }
diff --git a/crates/markdown_preview/src/markdown_preview_settings.rs b/crates/markdown_preview/src/markdown_preview_settings.rs
index 94bd4ab597b..ab22cd6476d 100644
--- a/crates/markdown_preview/src/markdown_preview_settings.rs
+++ b/crates/markdown_preview/src/markdown_preview_settings.rs
@@ -4,6 +4,8 @@ use settings::{IntoGpui, RegisterSetting, Settings};
/// The settings for the markdown preview.
#[derive(Clone, Copy, Debug, Default, RegisterSetting)]
pub struct MarkdownPreviewSettings {
+ /// Whether to automatically open Markdown files in the preview.
+ pub open_markdown_files_in_preview: bool,
/// The maximum width of the rendered markdown content, or `None` to render
/// content edge to edge.
pub max_width: Option<Pixels>,
@@ -17,6 +19,9 @@ impl Settings for MarkdownPreviewSettings {
} else {
None
};
- Self { max_width }
+ Self {
+ open_markdown_files_in_preview: content.open_markdown_files_in_preview.unwrap_or(false),
+ max_width,
+ }
}
}
diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rs
index 2f18d914a36..0dcc13077fc 100644
--- a/crates/markdown_preview/src/markdown_preview_view.rs
+++ b/crates/markdown_preview/src/markdown_preview_view.rs
@@ -1,6 +1,7 @@
use std::any::TypeId;
use std::borrow::Cow;
use std::cmp::min;
+use std::collections::HashSet;
use std::ops::Range;
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -13,9 +14,10 @@ use editor::{
Editor, EditorEvent, EditorSettingsScrollbarProxy, MultiBufferOffset, SelectionEffects,
};
use gpui::{
- App, ClipboardItem, Context, Entity, EventEmitter, FocusHandle, Focusable, ImageSource,
- InteractiveElement, IntoElement, IsZero, Pixels, Render, Resource, RetainAllImageCache,
- ScrollHandle, SharedString, SharedUri, Subscription, Task, WeakEntity, Window, point, px,
+ App, ClipboardItem, Context, Entity, EntityId, EventEmitter, FocusHandle, Focusable, Global,
+ ImageSource, InteractiveElement, IntoElement, IsZero, Pixels, Render, Resource,
+ RetainAllImageCache, ScrollHandle, SharedString, SharedUri, Subscription, Task, WeakEntity,
+ Window, point, px,
};
use language::{Buffer, LanguageRegistry};
use markdown::{
@@ -55,6 +57,12 @@ use crate::{ScrollPageDown, ScrollPageUp, ScrollToBottom, ScrollToTop, ScrollUp,
const REPARSE_DEBOUNCE: Duration = Duration::from_millis(200);
+fn reset_persisted_font_size(settings: &mut settings::SettingsContent) {
+ if let Some(markdown_preview) = settings.markdown_preview.as_mut() {
+ markdown_preview.font_size = None;
+ }
+}
+
pub struct MarkdownPreviewView {
workspace: WeakEntity<Workspace>,
active_editor: Option<EditorState>,
@@ -102,6 +110,11 @@ struct EditorState {
_subscription: Subscription,
}
+#[derive(Default)]
+struct SuppressedAutoPreviews(HashSet<EntityId>);
+
+impl Global for SuppressedAutoPreviews {}
+
#[derive(Clone, Copy, Debug)]
pub enum MarkdownPreviewEvent {
SourceEditorChanged,
@@ -114,7 +127,69 @@ enum PreviewLinkTarget {
}
impl MarkdownPreviewView {
- pub fn register(workspace: &mut Workspace, _window: &mut Window, _cx: &mut Context<Workspace>) {
+ pub fn register(workspace: &mut Workspace, window: &mut Window, cx: &mut Context<Workspace>) {
+ cx.default_global::<SuppressedAutoPreviews>();
+ let workspace_entity = cx.entity();
+ cx.subscribe_in(
+ &workspace_entity,
+ window,
+ |workspace, _, event: &workspace::Event, window, cx| {
+ let workspace::Event::ItemAdded { item } = event else {
+ return;
+ };
+ if cx
+ .global_mut::<SuppressedAutoPreviews>()
+ .0
+ .remove(&item.item_id())
+ {
+ return;
+ }
+ if !MarkdownPreviewSettings::get_global(cx).open_markdown_files_in_preview
+ || workspace.is_restoring()
+ {
+ return;
+ }
+ let Some(editor) = item.downcast::<Editor>() else {
+ return;
+ };
+ if !Self::is_markdown_editor(workspace, &editor, cx) {
+ return;
+ }
+ let Some(pane) = workspace.pane_for_item_id(item.item_id()) else {
+ return;
+ };
+ let replaces_editor = !item.is_dirty(cx);
+ let replaces_temporary_editor =
+ replaces_editor && pane.read(cx).is_active_preview_item(item.item_id());
+ let activate = workspace.active_pane() == &pane
+ && pane
+ .read(cx)
+ .active_item()
+ .is_some_and(|active_item| active_item.item_id() == item.item_id());
+ let focus = editor.focus_handle(cx).contains_focused(window, cx);
+ let preview = Self::activate_or_add_preview(
+ workspace,
+ editor,
+ pane.clone(),
+ activate,
+ focus,
+ window,
+ cx,
+ );
+ if !replaces_editor {
+ return;
+ }
+ pane.update(cx, |pane, cx| {
+ if replaces_temporary_editor {
+ pane.replace_preview_item_id(preview.entity_id(), window, cx);
+ } else {
+ pane.remove_item(item.item_id(), false, false, window, cx);
+ }
+ });
+ },
+ )
+ .detach();
+
workspace.register_action(move |workspace, _: &OpenPreview, window, cx| {
if let Some(editor) = Self::resolve_active_item_as_markdown_editor(workspace, cx) {
let pane = workspace.active_pane().clone();
@@ -162,7 +237,7 @@ impl MarkdownPreviewView {
window: &mut Window,
cx: &mut Context<Workspace>,
) {
- Self::activate_or_add_preview(workspace, editor, pane, true, window, cx);
+ Self::activate_or_add_preview(workspace, editor, pane, true, true, window, cx);
}
pub fn open_preview_to_the_side_of_pane(
@@ -173,7 +248,15 @@ impl MarkdownPreviewView {
cx: &mut Context<Workspace>,
) {
let target_pane = workspace.adjacent_pane_of(&origin_pane, window, cx);
- Self::activate_or_add_preview(workspace, editor.clone(), target_pane, false, window, cx);
+ Self::activate_or_add_preview(
+ workspace,
+ editor.clone(),
+ target_pane,
+ false,
+ false,
+ window,
+ cx,
+ );
editor.focus_handle(cx).focus(window, cx);
}
@@ -181,42 +264,46 @@ impl MarkdownPreviewView {
workspace: &mut Workspace,
editor: Entity<Editor>,
pane: Entity<Pane>,
+ activate: bool,
focus: bool,
window: &mut Window,
cx: &mut Context<Workspace>,
- ) {
- let existing_view_idx =
+ ) -> Entity<MarkdownPreviewView> {
+ let existing_view =
Self::find_existing_independent_preview_item_idx(pane.read(cx), &editor, cx);
- if let Some(existing_view_idx) = existing_view_idx {
+ let view = if let Some((existing_view, existing_view_idx)) = existing_view {
pane.update(cx, |pane, cx| {
- pane.activate_item(existing_view_idx, focus, focus, window, cx);
+ pane.activate_item(existing_view_idx, activate, focus, window, cx);
});
+ existing_view
} else {
let view = Self::create_markdown_view(workspace, editor, window, cx);
pane.update(cx, |pane, cx| {
- pane.add_item(Box::new(view), focus, focus, None, window, cx)
+ pane.add_item(Box::new(view.clone()), activate, focus, None, window, cx)
});
- }
+ view
+ };
cx.notify();
+ view
}
fn find_existing_independent_preview_item_idx(
pane: &Pane,
editor: &Entity<Editor>,
cx: &App,
- ) -> Option<usize> {
+ ) -> Option<(Entity<MarkdownPreviewView>, usize)> {
let target_buffer = editor.read(cx).buffer().read(cx).as_singleton()?;
- pane.items_of_type::<MarkdownPreviewView>()
- .find(|view| {
- // Only look for independent (Default mode) previews, not Follow previews.
- // Match by buffer entity rather than editor entity so the lookup survives
- // workspace restoration, where the preview's bound editor may differ from
- // the editor the user is currently invoking the action on even though both
- // wrap the same source buffer.
- view.read(cx).mode == MarkdownPreviewMode::Default
- && view.read(cx).is_previewing(&target_buffer, cx)
- })
- .and_then(|view| pane.index_for_item(&view))
+ let view = pane.items_of_type::<MarkdownPreviewView>().find(|view| {
+ // Only look for independent (Default mode) previews, not Follow previews.
+ // Match by buffer entity rather than editor entity so the lookup survives
+ // workspace restoration, where the preview's bound editor may differ from
+ // the editor the user is currently invoking the action on even though both
+ // wrap the same source buffer.
+ view.read(cx).mode == MarkdownPreviewMode::Default
+ && view.read(cx).is_previewing(&target_buffer, cx)
+ })?;
+ let index = pane.index_for_item(&view)?;
+ Some((view, index))
}
fn is_previewing(&self, buffer: &Entity<Buffer>, cx: &App) -> bool {
@@ -433,6 +520,24 @@ impl MarkdownPreviewView {
false
}
+ fn is_markdown_editor(workspace: &Workspace, editor: &Entity<Editor>, cx: &App) -> bool {
+ let Some(buffer) = editor.read(cx).buffer().read(cx).as_singleton() else {
+ return false;
+ };
+ let buffer = buffer.read(cx);
+ if let Some(language) = buffer.language() {
+ return language.name() == "Markdown";
+ }
+ let Some(file) = buffer.file() else {
+ return false;
+ };
+ let languages = workspace.project().read(cx).languages().clone();
+ let Some(markdown) = languages.available_language_for_name("Markdown") else {
+ return false;
+ };
+ languages.language_for_file(file, None, cx) == Some(markdown.id())
+ }
+
fn set_editor(&mut self, editor: Entity<Editor>, window: &mut Window, cx: &mut Context<Self>) {
if let Some(active) = &self.active_editor
&& active.editor == editor
@@ -466,11 +571,8 @@ impl MarkdownPreviewView {
(index, focused)
});
if let Some(selection_start) = selection_start {
- this.sync_preview_to_source_index(
- selection_start,
- editor_is_focused,
- cx,
- );
+ let reveal = editor_is_focused || this.focus_handle.is_focused(window);
+ this.sync_preview_to_source_index(selection_start, reveal, cx);
cx.notify();
}
}
@@ -758,7 +860,7 @@ impl MarkdownPreviewView {
};
update_settings_file(fs, cx, move |settings, cx| {
let size = ThemeSettings::get_global(cx).markdown_preview_font_size(cx) + delta;
- settings.theme.markdown_preview_font_size =
+ settings.markdown_preview.get_or_insert_default().font_size =
Some(f32::from(theme_settings::clamp_font_size(size)).into());
});
} else {
@@ -780,7 +882,7 @@ impl MarkdownPreviewView {
return;
};
update_settings_file(fs, cx, move |settings, _| {
- settings.theme.markdown_preview_font_size = None;
+ reset_persisted_font_size(settings);
});
} else {
theme_settings::reset_markdown_preview_font_size(cx);
@@ -922,6 +1024,10 @@ impl MarkdownPreviewView {
window.defer(cx, move |window, cx| {
workspace.update(cx, |workspace, cx| {
if !workspace.activate_item(&editor, true, true, window, cx) {
+ // Re-adding the source emits `ItemAdded`; suppress its automatic preview once.
+ cx.global_mut::<SuppressedAutoPreviews>()
+ .0
+ .insert(editor.entity_id());
workspace.add_item_to_active_pane(Box::new(editor), None, true, window, cx);
}
@@ -935,7 +1041,7 @@ impl MarkdownPreviewView {
});
}
- /// Returns the theme chosen in `markdown_preview_theme`, or `None` if the
+ /// Returns the theme chosen in `markdown_preview.theme`, or `None` if the
/// user hasn't set one or it can't be resolved.
fn resolve_preview_theme(&self, cx: &App) -> Option<Arc<Theme>> {
let theme_settings = ThemeSettings::get_global(cx);
@@ -2092,7 +2198,9 @@ mod tests {
use crate::markdown_preview_view::resolve_project_path_for_preview_image;
use buffer_diff::BufferDiff;
use editor::Editor;
+ use editor::items::open_resolved_target;
use fs::FakeFs;
+ use gpui::UpdateGlobal as _;
use gpui::{
App, AppContext as _, Entity, Focusable as _, Modifiers, TestAppContext, WindowHandle, px,
};
@@ -2103,15 +2211,19 @@ mod tests {
use std::sync::Arc;
use std::time::Duration;
use util::path;
- use util::paths::PathStyle;
+ use util::paths::{PathStyle, PathWithPosition};
use util::rel_path::{RelPath, rel_path};
use util::test::TempTree;
- use workspace::item::SerializableItem;
+ use workspace::item::{ItemHandle, SerializableItem};
+ use workspace::path_link::{OpenTarget, OpenTargetFoundBy};
use workspace::{
- AppState, ItemId, MultiWorkspace, SaveIntent, Workspace, WorkspaceId, open_paths,
+ AppState, ItemId, MultiWorkspace, Pane, SaveIntent, Workspace, WorkspaceId, open_paths,
};
- use super::{MarkdownPreviewView, filter_non_rendered_matches, open_preview_url};
+ use super::{
+ MarkdownPreviewView, filter_non_rendered_matches, open_preview_url,
+ reset_persisted_font_size,
+ };
#[test]
fn filters_matches_in_non_rendered_link_source() {
@@ -2134,6 +2246,32 @@ mod tests {
);
}
+ #[gpui::test]
+ fn resetting_persisted_font_size_preserves_unrelated_settings(cx: &mut App) {
+ let settings_store = settings::SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ let without_markdown_preview = "{\n \"buffer_font_size\": 14\n}\n".to_string();
+ assert_eq!(
+ cx.global::<settings::SettingsStore>()
+ .new_text_for_update(without_markdown_preview.clone(), reset_persisted_font_size)
+ .unwrap(),
+ without_markdown_preview
+ );
+
+ let updated = cx
+ .global::<settings::SettingsStore>()
+ .new_text_for_update(
+ r#"{"markdown_preview":{"font_size":18,"open_markdown_files_in_preview":true}}"#
+ .into(),
+ reset_persisted_font_size,
+ )
+ .unwrap();
+ assert_eq!(
+ serde_json::from_str::<serde_json::Value>(&updated).unwrap(),
+ json!({"markdown_preview": {"open_markdown_files_in_preview": true}})
+ );
+ }
+
#[gpui::test]
fn resolves_workspace_absolute_preview_image_path_and_rejects_missing(cx: &mut App) {
let tree = TempTree::new(json!({
@@ -3044,6 +3182,34 @@ mod tests {
assert_no_markdown_preview_items(cx, &multi_workspace);
}
+ #[gpui::test]
+ async fn close_and_return_to_editor_returns_to_source_when_auto_preview_is_enabled(
+ cx: &mut TestAppContext,
+ ) {
+ let (project, workspace, multi_workspace) =
+ markdown_workspace(cx, json!({ "note.md": "# Note\n" }), false).await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+
+ open_project_file(cx, &project, &multi_workspace, "note.md", None, true).await;
+
+ let preview = cx.update(|cx| {
+ assert_eq!(workspace.read(cx).items_of_type::<Editor>(cx).count(), 0);
+ workspace
+ .read(cx)
+ .active_item_as::<MarkdownPreviewView>(cx)
+ .unwrap()
+ });
+ let editor = preview.read_with(cx, |preview, _| {
+ preview.active_editor.as_ref().unwrap().editor.clone()
+ });
+
+ dispatch_close_and_return_to_editor(cx, &multi_workspace, &preview);
+ cx.run_until_parked();
+
+ assert_editor_is_active_and_focused(cx, &multi_workspace, &editor);
+ assert_no_markdown_preview_items(cx, &multi_workspace);
+ }
+
#[gpui::test]
async fn preview_serialized_path_updates_when_source_file_is_renamed(cx: &mut TestAppContext) {
let app_state = init_test(cx);
@@ -3504,6 +3670,377 @@ mod tests {
.unwrap();
}
+ #[gpui::test]
+ async fn opens_markdown_files_in_preview_when_enabled(cx: &mut TestAppContext) {
+ let (project, workspace, multi_workspace) = markdown_workspace(
+ cx,
+ json!({
+ "automatic.md": "# Automatic\n",
+ "plain.txt": "Plain text\n",
+ "targeted.md": "# Targeted\n",
+ }),
+ false,
+ )
+ .await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+
+ let automatic_editor =
+ open_project_file(cx, &project, &multi_workspace, "automatic.md", None, true).await;
+ cx.update(|cx| {
+ assert_editor_replaced_by_preview(workspace.read(cx), automatic_editor.as_ref(), cx);
+ });
+
+ open_project_file(cx, &project, &multi_workspace, "plain.txt", None, true).await;
+ cx.update(|cx| {
+ assert!(workspace.read(cx).active_item_as::<Editor>(cx).is_some());
+ });
+
+ let (target_pane, other_pane) = multi_workspace
+ .update(cx, |_, window, cx| {
+ workspace.update(cx, |workspace, cx| {
+ let target_pane = workspace.active_pane().clone();
+ let other_pane = workspace.split_pane(
+ target_pane.clone(),
+ workspace::SplitDirection::Right,
+ window,
+ cx,
+ );
+ (target_pane, other_pane)
+ })
+ })
+ .unwrap();
+ open_project_file(
+ cx,
+ &project,
+ &multi_workspace,
+ "targeted.md",
+ Some(&target_pane),
+ true,
+ )
+ .await;
+ let preview = cx.update(|cx| {
+ let preview = target_pane
+ .read(cx)
+ .active_item()
+ .and_then(|item| item.downcast::<MarkdownPreviewView>())
+ .expect("the Markdown preview should open in the requested pane");
+ assert_eq!(
+ other_pane
+ .read(cx)
+ .items_of_type::<MarkdownPreviewView>()
+ .count(),
+ 0
+ );
+ preview
+ });
+ assert_eq!(
+ preview_source_path(cx, &preview).as_ref(),
+ rel_path("targeted.md")
+ );
+ }
+
+ #[gpui::test]
+ async fn first_markdown_file_opens_in_preview_before_language_load(cx: &mut TestAppContext) {
+ let (project, workspace, multi_workspace) =
+ markdown_workspace(cx, json!({ "note.md": "# Note\n" }), true).await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+ let editor = open_project_file(cx, &project, &multi_workspace, "note.md", None, true)
+ .await
+ .downcast::<Editor>()
+ .unwrap();
+
+ cx.update(|cx| {
+ assert_editor_replaced_by_preview(workspace.read(cx), &editor, cx);
+ });
+ }
+
+ #[gpui::test]
+ async fn workspace_restore_does_not_auto_preview_markdown(cx: &mut TestAppContext) {
+ let (project, workspace, multi_workspace) = markdown_workspace(
+ cx,
+ json!({
+ "restored.md": "# Restored\n",
+ "ordinary.md": "# Ordinary\n",
+ }),
+ false,
+ )
+ .await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+ workspace.update(cx, |workspace, _| workspace.set_restoring_workspace(true));
+
+ let restored_editor =
+ open_project_file(cx, &project, &multi_workspace, "restored.md", None, true)
+ .await
+ .downcast::<Editor>()
+ .unwrap();
+ cx.update(|cx| {
+ let workspace = workspace.read(cx);
+ assert_eq!(
+ workspace.active_item_as::<Editor>(cx),
+ Some(restored_editor)
+ );
+ assert_eq!(
+ workspace.items_of_type::<MarkdownPreviewView>(cx).count(),
+ 0
+ );
+ });
+
+ workspace.update(cx, |workspace, _| workspace.set_restoring_workspace(false));
+ let ordinary_editor =
+ open_project_file(cx, &project, &multi_workspace, "ordinary.md", None, true)
+ .await
+ .downcast::<Editor>()
+ .unwrap();
+ cx.update(|cx| {
+ assert_editor_replaced_by_preview(workspace.read(cx), &ordinary_editor, cx);
+ });
+ }
+
+ #[gpui::test]
+ async fn dirty_markdown_editor_is_retained_when_auto_preview_runs(cx: &mut TestAppContext) {
+ let (project, workspace, multi_workspace) =
+ markdown_workspace(cx, json!({ "note.md": "# Note\n" }), false).await;
+ let editor = open_project_file(cx, &project, &multi_workspace, "note.md", None, true)
+ .await
+ .downcast::<Editor>()
+ .unwrap();
+ editor.update(cx, |editor, cx| {
+ let end = editor.buffer().read(cx).snapshot(cx).len();
+ editor.edit([(end..end, "dirty\n")], cx);
+ });
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+
+ multi_workspace
+ .update(cx, |_, window, cx| {
+ workspace.update(cx, |workspace, cx| {
+ workspace.add_item_to_active_pane(
+ Box::new(editor.clone()),
+ None,
+ true,
+ window,
+ cx,
+ );
+ });
+ })
+ .unwrap();
+ cx.run_until_parked();
+
+ cx.update(|cx| {
+ let workspace = workspace.read(cx);
+ assert!(
+ workspace
+ .panes()
+ .iter()
+ .any(|pane| pane.read(cx).index_for_item(&editor).is_some())
+ );
+ assert_eq!(
+ workspace.items_of_type::<MarkdownPreviewView>(cx).count(),
+ 1
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn automatic_previews_preserve_temporary_tab_semantics(cx: &mut TestAppContext) {
+ let (project, workspace, multi_workspace) = markdown_workspace(
+ cx,
+ json!({
+ "first.md": "# First\n",
+ "second.md": "# Second\n",
+ }),
+ false,
+ )
+ .await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+
+ for path in ["first.md", "second.md"] {
+ let open = multi_workspace
+ .update(cx, |_, window, cx| {
+ workspace.update(cx, |workspace, cx| {
+ workspace.open_path_preview(
+ test_project_path(&project, path, cx),
+ None,
+ true,
+ true,
+ true,
+ window,
+ cx,
+ )
+ })
+ })
+ .unwrap();
+ open.await.unwrap();
+ cx.run_until_parked();
+
+ let preview = cx.update(|cx| {
+ let pane = workspace.read(cx).active_pane().read(cx);
+ let preview = pane
+ .preview_item()
+ .and_then(|item| item.downcast::<MarkdownPreviewView>())
+ .unwrap();
+ assert_eq!(pane.items_len(), 1);
+ preview
+ });
+ assert_eq!(preview_source_path(cx, &preview).as_ref(), rel_path(path));
+ }
+ }
+
+ #[gpui::test]
+ async fn automatic_preview_preserves_pane_activation_and_focus(cx: &mut TestAppContext) {
+ let (project, workspace, multi_workspace) = markdown_workspace(
+ cx,
+ json!({
+ "plain.txt": "Plain\n",
+ "active.md": "# Active\n",
+ "background.md": "# Background\n",
+ }),
+ false,
+ )
+ .await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+ let plain_editor =
+ open_project_file(cx, &project, &multi_workspace, "plain.txt", None, true)
+ .await
+ .downcast::<Editor>()
+ .unwrap();
+
+ let (plain_pane, target_pane) = multi_workspace
+ .update(cx, |_, window, cx| {
+ workspace.update(cx, |workspace, cx| {
+ let plain_pane = workspace.active_pane().clone();
+ let target_pane = workspace.split_pane(
+ plain_pane.clone(),
+ workspace::SplitDirection::Right,
+ window,
+ cx,
+ );
+ plain_editor.focus_handle(cx).focus(window, cx);
+ (plain_pane, target_pane)
+ })
+ })
+ .unwrap();
+ open_project_file(
+ cx,
+ &project,
+ &multi_workspace,
+ "active.md",
+ Some(&target_pane),
+ false,
+ )
+ .await;
+
+ let target_preview = multi_workspace
+ .update(cx, |_, window, cx| {
+ assert_eq!(workspace.read(cx).active_pane(), &target_pane);
+ let target_preview = target_pane
+ .read(cx)
+ .active_item()
+ .and_then(|item| item.downcast::<MarkdownPreviewView>())
+ .unwrap();
+ assert!(plain_editor.focus_handle(cx).contains_focused(window, cx));
+ target_preview
+ })
+ .unwrap();
+ multi_workspace
+ .update(cx, |_, window, cx| {
+ target_preview.focus_handle(cx).focus(window, cx);
+ })
+ .unwrap();
+
+ let open_background = multi_workspace
+ .update(cx, |_, window, cx| {
+ workspace.update(cx, |workspace, cx| {
+ workspace.open_path_preview(
+ test_project_path(&project, "background.md", cx),
+ Some(plain_pane.downgrade()),
+ false,
+ false,
+ false,
+ window,
+ cx,
+ )
+ })
+ })
+ .unwrap();
+ open_background.await.unwrap();
+ cx.run_until_parked();
+
+ multi_workspace
+ .update(cx, |_, window, cx| {
+ assert_eq!(workspace.read(cx).active_pane(), &target_pane);
+ assert!(
+ plain_pane
+ .read(cx)
+ .active_item()
+ .and_then(|item| item.downcast::<MarkdownPreviewView>())
+ .is_some()
+ );
+ assert!(target_preview.focus_handle(cx).contains_focused(window, cx));
+ })
+ .unwrap();
+ }
+
+ #[gpui::test]
+ async fn targeted_markdown_open_reveals_the_source_position(cx: &mut TestAppContext) {
+ let (_project, workspace, multi_workspace) = markdown_workspace(
+ cx,
+ json!({ "note.md": "# Heading\n\nFirst line\nTarget line\n" }),
+ false,
+ )
+ .await;
+ cx.update(|cx| set_auto_preview_enabled(cx, true));
+ let open_target = OpenTarget::Path(
+ PathWithPosition {
+ path: PathBuf::from(path!("/project/note.md")),
+ row: Some(4),
+ column: Some(3),
+ },
+ false,
+ OpenTargetFoundBy::BackgroundPathResolution,
+ );
+ let open = multi_workspace
+ .update(cx, |_, window, cx| {
+ workspace.update(cx, |_, cx| {
+ cx.spawn_in(window, async move |workspace, cx| {
+ open_resolved_target(&workspace, &open_target, cx).await
+ })
+ })
+ })
+ .unwrap();
+ assert!(open.await.unwrap());
+ cx.run_until_parked();
+
+ multi_workspace
+ .update(cx, |_, window, cx| {
+ let preview = workspace
+ .read(cx)
+ .active_item_as::<MarkdownPreviewView>(cx)
+ .unwrap();
+ let editor = preview
+ .read(cx)
+ .active_editor
+ .as_ref()
+ .unwrap()
+ .editor
+ .clone();
+ let source_index = editor
+ .update(cx, |editor, cx| {
+ MarkdownPreviewView::selected_source_index(editor, cx)
+ })
+ .unwrap();
+ assert_eq!(preview.read(cx).active_source_index, Some(source_index));
+ assert!(preview.read(cx).focus_handle.is_focused(window));
+ assert!(
+ workspace
+ .read(cx)
+ .panes()
+ .iter()
+ .all(|pane| { pane.read(cx).index_for_item(&editor).is_none() })
+ );
+ })
+ .unwrap();
+ }
+
#[gpui::test]
async fn preview_opens_for_the_given_pane_not_the_focused_editor(cx: &mut TestAppContext) {
let app_state = init_test(cx);
@@ -3654,6 +4191,7 @@ mod tests {
fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
cx.update(|cx| {
+ cx.set_global(db::AppDatabase::test_new());
let state = AppState::test(cx);
editor::init(cx);
crate::init(cx);
@@ -3661,21 +4199,118 @@ mod tests {
})
}
+ async fn markdown_workspace(
+ cx: &mut TestAppContext,
+ files: serde_json::Value,
+ lazy_language: bool,
+ ) -> (
+ Entity<Project>,
+ Entity<Workspace>,
+ WindowHandle<MultiWorkspace>,
+ ) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(path!("/project"), files).await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ if lazy_language {
+ register_lazy_markdown_language(&project, cx);
+ } else {
+ register_markdown_language(&project, cx);
+ }
+ let multi_workspace =
+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let workspace = multi_workspace
+ .update(cx, |multi_workspace, _, _| {
+ multi_workspace.workspace().clone()
+ })
+ .unwrap();
+ (project, workspace, multi_workspace)
+ }
+
+ async fn open_project_file(
+ cx: &mut TestAppContext,
+ project: &Entity<Project>,
+ multi_workspace: &WindowHandle<MultiWorkspace>,
+ path: &str,
+ pane: Option<&Entity<Pane>>,
+ focus_item: bool,
+ ) -> Box<dyn ItemHandle> {
+ let open = multi_workspace
+ .update(cx, |multi_workspace, window, cx| {
+ multi_workspace.workspace().update(cx, |workspace, cx| {
+ workspace.open_path(
+ test_project_path(project, path, cx),
+ pane.map(Entity::downgrade),
+ focus_item,
+ window,
+ cx,
+ )
+ })
+ })
+ .unwrap();
+ let item = open.await.unwrap();
+ cx.run_until_parked();
+ item
+ }
+
+ fn assert_editor_replaced_by_preview(workspace: &Workspace, editor: &dyn ItemHandle, cx: &App) {
+ assert!(
+ workspace
+ .active_item_as::<MarkdownPreviewView>(cx)
+ .is_some()
+ );
+ assert!(
+ workspace
+ .panes()
+ .iter()
+ .all(|pane| pane.read(cx).index_for_item(editor).is_none())
+ );
+ }
+
+ fn set_auto_preview_enabled(cx: &mut App, enabled: bool) {
+ settings::SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings
+ .markdown_preview
+ .get_or_insert_default()
+ .open_markdown_files_in_preview = Some(enabled);
+ });
+ });
+ }
+
+ fn test_project_path(project: &Entity<Project>, path: &str, cx: &App) -> ProjectPath {
+ let worktree_id = project.read(cx).worktrees(cx).next().unwrap().read(cx).id();
+ ProjectPath {
+ worktree_id,
+ path: rel_path(path).into(),
+ }
+ }
+
+ fn markdown_language_config() -> language::LanguageConfig {
+ language::LanguageConfig {
+ name: "Markdown".into(),
+ matcher: Arc::new(language::LanguageMatcher {
+ path_suffixes: vec!["md".to_string(), "markdown".to_string()],
+ ..Default::default()
+ }),
+ ..Default::default()
+ }
+ }
+
fn register_markdown_language(project: &Entity<Project>, cx: &mut TestAppContext) {
let languages = project.read_with(cx, |project, _| project.languages().clone());
languages.add(Arc::new(language::Language::new(
- language::LanguageConfig {
- name: "Markdown".into(),
- matcher: Arc::new(language::LanguageMatcher {
- path_suffixes: vec!["md".to_string(), "markdown".to_string()],
- ..Default::default()
- }),
- ..Default::default()
- },
+ markdown_language_config(),
None,
)));
}
+ fn register_lazy_markdown_language(project: &Entity<Project>, cx: &mut TestAppContext) {
+ project
+ .read_with(cx, |project, _| project.languages().clone())
+ .register_test_language(markdown_language_config());
+ }
+
async fn wait_for_preview_serialization(cx: &mut TestAppContext) {
cx.run_until_parked();
cx.executor().advance_clock(Duration::from_millis(250));
diff --git a/crates/migrator/src/migrations.rs b/crates/migrator/src/migrations.rs
index 5592449c87a..2088dfc4ecb 100644
--- a/crates/migrator/src/migrations.rs
+++ b/crates/migrator/src/migrations.rs
@@ -370,3 +370,9 @@ pub(crate) mod m_2026_08_26 {
pub(crate) use settings::rename_folder_icons_to_folder_indicator;
}
+
+pub(crate) mod m_2026_08_30 {
+ mod settings;
+
+ pub(crate) use settings::nest_markdown_preview_settings;
+}
diff --git a/crates/migrator/src/migrations/m_2026_08_30/settings.rs b/crates/migrator/src/migrations/m_2026_08_30/settings.rs
new file mode 100644
index 00000000000..142ab0a093f
--- /dev/null
+++ b/crates/migrator/src/migrations/m_2026_08_30/settings.rs
@@ -0,0 +1,56 @@
+use anyhow::Result;
+use serde_json::Value;
+
+use crate::migrations::migrate_settings;
+
+const MARKDOWN_PREVIEW_KEY: &str = "markdown_preview";
+const KEY_MAPPINGS: &[(&str, &str)] = &[
+ ("markdown_preview_font_size", "font_size"),
+ ("markdown_preview_font_family", "font_family"),
+ ("markdown_preview_code_font_family", "code_font_family"),
+ ("markdown_preview_theme", "theme"),
+];
+
+pub fn nest_markdown_preview_settings(value: &mut Value) -> Result<()> {
+ migrate_settings(value, &mut migrate_one)
+}
+
+fn migrate_one(object: &mut serde_json::Map<String, Value>) -> Result<()> {
+ let has_legacy_settings = KEY_MAPPINGS
+ .iter()
+ .any(|(old_key, _)| object.contains_key(*old_key));
+ match object.get(MARKDOWN_PREVIEW_KEY) {
+ Some(Value::Null) if has_legacy_settings => {
+ object.remove(MARKDOWN_PREVIEW_KEY);
+ }
+ Some(markdown_preview) if !markdown_preview.is_object() => return Ok(()),
+ _ => {}
+ }
+
+ let migrated_settings = KEY_MAPPINGS
+ .iter()
+ .filter_map(|(old_key, new_key)| {
+ object
+ .remove(*old_key)
+ .map(|value| ((*new_key).to_string(), value))
+ })
+ .collect::<Vec<_>>();
+
+ if migrated_settings.is_empty() {
+ return Ok(());
+ }
+
+ let Some(markdown_preview) = object
+ .entry(MARKDOWN_PREVIEW_KEY)
+ .or_insert_with(|| Value::Object(serde_json::Map::new()))
+ .as_object_mut()
+ else {
+ return Ok(());
+ };
+
+ for (key, value) in migrated_settings {
+ markdown_preview.entry(key).or_insert(value);
+ }
+
+ Ok(())
+}
diff --git a/crates/migrator/src/migrator.rs b/crates/migrator/src/migrator.rs
index acf5289e0cc..eba88345a9e 100644
--- a/crates/migrator/src/migrator.rs
+++ b/crates/migrator/src/migrator.rs
@@ -255,6 +255,7 @@ pub fn migrate_settings(text: &str) -> Result<Option<String>> {
),
MigrationType::Json(migrations::m_2026_08_17::make_git_gutter_width_an_enum),
MigrationType::Json(migrations::m_2026_08_26::rename_folder_icons_to_folder_indicator),
+ MigrationType::Json(migrations::m_2026_08_30::nest_markdown_preview_settings),
];
run_migrations(text, migrations)
}
@@ -5543,4 +5544,198 @@ mod tests {
),
);
}
+
+ #[test]
+ fn test_nest_markdown_preview_settings_across_all_scopes() {
+ assert_migrate_with_migrations(
+ &[MigrationType::Json(
+ migrations::m_2026_08_30::nest_markdown_preview_settings,
+ )],
+ &r#"
+ {
+ "markdown_preview_font_size": 14,
+ "macos": {
+ "markdown_preview_font_size": 15
+ },
+ "preview": {
+ "markdown_preview_font_size": 16
+ },
+ "profiles": {
+ "work": {
+ "settings": {
+ "markdown_preview_font_size": 17
+ }
+ }
+ }
+ }
+ "#
+ .unindent(),
+ Some(
+ &r#"
+ {
+ "markdown_preview": {
+ "font_size": 14
+ },
+ "macos": {
+ "markdown_preview": {
+ "font_size": 15
+ }
+ },
+ "preview": {
+ "markdown_preview": {
+ "font_size": 16
+ }
+ },
+ "profiles": {
+ "work": {
+ "settings": {
+ "markdown_preview": {
+ "font_size": 17
+ }
+ }
+ }
+ }
+ }
+ "#
+ .unindent(),
+ ),
+ );
+ }
+
+ #[test]
+ fn test_nest_markdown_preview_settings_merges_without_clobbering() {
+ assert_migrate_with_migrations(
+ &[MigrationType::Json(
+ migrations::m_2026_08_30::nest_markdown_preview_settings,
+ )],
+ &r#"
+ {
+ "markdown_preview_font_size": 15,
+ "markdown_preview_font_family": "Zed Sans",
+ "markdown_preview_code_font_family": "Zed Mono",
+ "markdown_preview_theme": "One Dark",
+ "markdown_preview": {
+ "font_size": 18,
+ "limit_content_width": false,
+ "max_width": 900
+ }
+ }
+ "#
+ .unindent(),
+ Some(
+ &r#"
+ {
+ "markdown_preview": {
+ "theme": "One Dark",
+ "code_font_family": "Zed Mono",
+ "font_family": "Zed Sans",
+ "font_size": 18,
+ "limit_content_width": false,
+ "max_width": 900
+ }
+ }
+ "#
+ .unindent(),
+ ),
+ );
+ }
+
+ #[test]
+ fn test_nest_markdown_preview_settings_leaves_malformed_object() {
+ assert_migrate_with_migrations(
+ &[MigrationType::Json(
+ migrations::m_2026_08_30::nest_markdown_preview_settings,
+ )],
+ &r#"
+ {
+ "markdown_preview_font_size": 15,
+ "markdown_preview": false
+ }
+ "#
+ .unindent(),
+ None,
+ );
+ }
+
+ #[test]
+ fn test_nest_markdown_preview_settings_replaces_null_when_legacy_settings_exist() {
+ assert_migrate_with_migrations(
+ &[MigrationType::Json(
+ migrations::m_2026_08_30::nest_markdown_preview_settings,
+ )],
+ &r#"
+ {
+ "markdown_preview": null,
+ "markdown_preview_font_size": 15,
+ "preview": {
+ "markdown_preview": null,
+ "markdown_preview_theme": "One Dark"
+ }
+ }
+ "#
+ .unindent(),
+ Some(
+ &r#"
+ {
+ "markdown_preview": {
+ "font_size": 15
+ },
+ "preview": {
+ "markdown_preview": {
+ "theme": "One Dark"
+ }
+ }
+ }
+ "#
+ .unindent(),
+ ),
+ );
+ }
+
+ #[test]
+ fn test_nest_markdown_preview_settings_leaves_null_without_legacy_settings() {
+ assert_migrate_with_migrations(
+ &[MigrationType::Json(
+ migrations::m_2026_08_30::nest_markdown_preview_settings,
+ )],
+ &r#"
+ {
+ "markdown_preview": null,
+ "preview": {
+ "markdown_preview": null
+ }
+ }
+ "#
+ .unindent(),
+ None,
+ );
+ }
+
+ #[test]
+ fn test_nest_markdown_preview_settings_is_registered() {
+ assert_migrate_settings(
+ &r#"
+ {
+ "markdown_preview_font_size": 15,
+ "markdown_preview_font_family": "Zed Sans",
+ "markdown_preview_code_font_family": "Zed Mono",
+ "markdown_preview_theme": "One Dark"
+ }
+ "#
+ .unindent(),
+ Some(
+ &r#"
+ {
+ "markdown_preview": {
+ "font_size": 15,
+ "font_family": "Zed Sans",
+ "code_font_family": "Zed Mono",
+ "theme": "One Dark"
+ }
+ }
+ "#
+ .unindent(),
+ ),
+ );
+ }
}
diff --git a/crates/settings/src/vscode_import.rs b/crates/settings/src/vscode_import.rs
index 0b35e9705b9..a490b805180 100644
--- a/crates/settings/src/vscode_import.rs
+++ b/crates/settings/src/vscode_import.rs
@@ -1011,10 +1011,6 @@ impl VsCodeSettings {
agent_buffer_font_family: None,
agent_buffer_font_size: None,
git_commit_buffer_font_size: None,
- markdown_preview_font_family: None,
- markdown_preview_code_font_family: None,
- markdown_preview_font_size: None,
- markdown_preview_theme: None,
theme: None,
icon_theme: None,
ui_density: None,
diff --git a/crates/settings_content/src/settings_content.rs b/crates/settings_content/src/settings_content.rs
index 919f946507d..2f3efc04cad 100644
--- a/crates/settings_content/src/settings_content.rs
+++ b/crates/settings_content/src/settings_content.rs
@@ -1278,6 +1278,22 @@ pub enum LineIndicatorFormat {
#[with_fallible_options]
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, MergeFrom, Default, PartialEq)]
pub struct MarkdownPreviewSettingsContent {
+ /// The name of a font to use for rendering in the markdown preview.
+ /// Falls back to the UI font if unset.
+ pub font_family: Option<FontFamilyName>,
+ /// The name of a font to use for code (code blocks and inline code) in the
+ /// markdown preview. Falls back to the buffer font if unset.
+ pub code_font_family: Option<FontFamilyName>,
+ /// The font size to use for rendering in the markdown preview.
+ /// Falls back to the UI font size if unset.
+ pub font_size: Option<FontSize>,
+ /// The theme to use for the markdown preview.
+ /// Falls back to the main editor theme if unset.
+ pub theme: Option<ThemeSelection>,
+ /// Whether to automatically open Markdown files in the preview.
+ ///
+ /// Default: false
+ pub open_markdown_files_in_preview: Option<bool>,
/// Whether to limit the width of the rendered markdown content. When
/// enabled, content is constrained to `max_width` and centered
/// horizontally within the preview pane, for optimal readability.
diff --git a/crates/settings_content/src/theme.rs b/crates/settings_content/src/theme.rs
index cf12cce9710..649153e6007 100644
--- a/crates/settings_content/src/theme.rs
+++ b/crates/settings_content/src/theme.rs
@@ -214,18 +214,6 @@ pub struct ThemeSettingsContent {
/// The font size for user messages in the agent panel.
pub agent_buffer_font_size: Option<FontSize>,
pub git_commit_buffer_font_size: Option<FontSize>,
- /// The name of a font to use for rendering in the markdown preview.
- /// Falls back to the UI font if unset.
- pub markdown_preview_font_family: Option<FontFamilyName>,
- /// The name of a font to use for code (code blocks and inline code) in the
- /// markdown preview. Falls back to the buffer font if unset.
- pub markdown_preview_code_font_family: Option<FontFamilyName>,
- /// The font size to use for rendering in the markdown preview.
- /// Falls back to the UI font size if unset.
- pub markdown_preview_font_size: Option<FontSize>,
- /// The theme to use for the markdown preview.
- /// Falls back to the main editor theme if unset.
- pub markdown_preview_theme: Option<ThemeSelection>,
/// The name of the Zed theme to use.
pub theme: Option<ThemeSelection>,
/// The name of the icon theme to use.
diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs
index 31a556feee4..890fbaf2a53 100644
--- a/crates/settings_ui/src/page_data.rs
+++ b/crates/settings_ui/src/page_data.rs
@@ -1254,12 +1254,19 @@ fn appearance_page() -> SettingsPage {
description: "Font family for the markdown preview. Falls back to the UI font family.",
field: Box::new(SettingField {
organization_override: None,
- json_path: Some("markdown_preview_font_family"),
+ json_path: Some("markdown_preview.font_family"),
pick: |settings_content| {
- settings_content.theme.markdown_preview_font_family.as_ref()
+ settings_content
+ .markdown_preview
+ .as_ref()?
+ .font_family
+ .as_ref()
},
write: |settings_content, value, _| {
- settings_content.theme.markdown_preview_font_family = value;
+ settings_content
+ .markdown_preview
+ .get_or_insert_default()
+ .font_family = value;
},
}),
metadata: None,
@@ -1270,15 +1277,19 @@ fn appearance_page() -> SettingsPage {
description: "Font family for code blocks in the markdown preview. Falls back to the editor font family.",
field: Box::new(SettingField {
organization_override: None,
- json_path: Some("markdown_preview_code_font_family"),
+ json_path: Some("markdown_preview.code_font_family"),
pick: |settings_content| {
settings_content
- .theme
- .markdown_preview_code_font_family
+ .markdown_preview
+ .as_ref()?
+ .code_font_family
.as_ref()
},
write: |settings_content, value, _| {
- settings_content.theme.markdown_preview_code_font_family = value;
+ settings_content
+ .markdown_preview
+ .get_or_insert_default()
+ .code_font_family = value;
},
}),
metadata: None,
@@ -1289,16 +1300,19 @@ fn appearance_page() -> SettingsPage {
description: "Font size for the markdown preview. Falls back to the editor font size.",
field: Box::new(SettingField {
organization_override: None,
- json_path: Some("markdown_preview_font_size"),
+ json_path: Some("markdown_preview.font_size"),
pick: |settings_content| {
settings_content
- .theme
- .markdown_preview_font_size
+ .markdown_preview
.as_ref()
+ .and_then(|preview| preview.font_size.as_ref())
.or(settings_content.theme.buffer_font_size.as_ref())
},
write: |settings_content, value, _| {
- settings_content.theme.markdown_preview_font_size = value;
+ settings_content
+ .markdown_preview
+ .get_or_insert_default()
+ .font_size = value;
},
}),
metadata: None,
@@ -10271,7 +10285,7 @@ fn language_settings_data() -> Box<[SettingsPageItem]> {
]
}
- fn global_only_miscellaneous_sub_section() -> [SettingsPageItem; 3] {
+ fn global_only_miscellaneous_sub_section() -> [SettingsPageItem; 4] {
[
SettingsPageItem::SettingItem(SettingItem {
title: "Image Viewer",
@@ -10292,6 +10306,29 @@ fn language_settings_data() -> Box<[SettingsPageItem]> {
metadata: None,
files: USER,
}),
+ SettingsPageItem::SettingItem(SettingItem {
+ title: "Open Markdown Files in Preview",
+ description: "Whether to automatically open Markdown files in the preview.",
+ field: Box::new(SettingField {
+ organization_override: None,
+ json_path: Some("markdown_preview.open_markdown_files_in_preview"),
+ pick: |settings_content| {
+ settings_content
+ .markdown_preview
+ .as_ref()?
+ .open_markdown_files_in_preview
+ .as_ref()
+ },
+ write: |settings_content, value, _| {
+ settings_content
+ .markdown_preview
+ .get_or_insert_default()
+ .open_markdown_files_in_preview = value;
+ },
+ }),
+ metadata: None,
+ files: USER,
+ }),
SettingsPageItem::DynamicItem(DynamicItem {
discriminant: SettingItem {
files: USER,
diff --git a/crates/theme_settings/src/settings.rs b/crates/theme_settings/src/settings.rs
index d9a3270ef32..cd632bb018f 100644
--- a/crates/theme_settings/src/settings.rs
+++ b/crates/theme_settings/src/settings.rs
@@ -702,8 +702,9 @@ fn font_fallbacks_from_settings(
}
impl settings::Settings for ThemeSettings {
- fn from_settings(content: &settings::SettingsContent) -> Self {
- let content = &content.theme;
+ fn from_settings(settings_content: &settings::SettingsContent) -> Self {
+ let content = &settings_content.theme;
+ let markdown_preview = settings_content.markdown_preview.as_ref();
let theme_selection: ThemeSelection = content.theme.clone().unwrap().into();
let icon_theme_selection: IconThemeSelection = content.icon_theme.clone().unwrap().into();
Self {
@@ -743,18 +744,17 @@ impl settings::Settings for ThemeSettings {
.map(|font| font.0.clone().into()),
agent_buffer_font_size: content.agent_buffer_font_size.map(|s| s.into_gpui()),
git_commit_buffer_font_size: content.git_commit_buffer_font_size.map(|s| s.into_gpui()),
- markdown_preview_font_family: content
- .markdown_preview_font_family
- .as_ref()
+ markdown_preview_font_family: markdown_preview
+ .and_then(|preview| preview.font_family.as_ref())
.map(|f| f.0.clone().into()),
- markdown_preview_code_font_family: content
- .markdown_preview_code_font_family
- .as_ref()
+ markdown_preview_code_font_family: markdown_preview
+ .and_then(|preview| preview.code_font_family.as_ref())
.map(|f| f.0.clone().into()),
- markdown_preview_font_size: content.markdown_preview_font_size.map(|s| s.into_gpui()),
- markdown_preview_theme: content
- .markdown_preview_theme
- .clone()
+ markdown_preview_font_size: markdown_preview
+ .and_then(|preview| preview.font_size)
+ .map(|size| size.into_gpui()),
+ markdown_preview_theme: markdown_preview
+ .and_then(|preview| preview.theme.clone())
.map(ThemeSelection::from),
theme: theme_selection,
experimental_theme_overrides: content.experimental_theme_overrides.clone(),
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 452f6277982..d939f9bfa1e 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -2733,6 +2733,15 @@ impl Workspace {
&self.app_state
}
+ pub fn is_restoring(&self) -> bool {
+ self.restoring_workspace
+ }
+
+ #[cfg(any(test, feature = "test-support"))]
+ pub fn set_restoring_workspace(&mut self, restoring: bool) {
+ self.restoring_workspace = restoring;
+ }
+
pub fn set_panels_task(&mut self, task: Task<Result<()>>) {
self._panels_task = Some(task);
}
diff --git a/docs/src/visual-customization.md b/docs/src/visual-customization.md
index afb301efc49..f40ebd36fc5 100644
--- a/docs/src/visual-customization.md
+++ b/docs/src/visual-customization.md
@@ -78,15 +78,17 @@ If you would like to use distinct themes for light mode/dark mode that can be se
// and any other snippet of code.
"agent_buffer_font_size": 12,
- // Controls the font size for the markdown preview.
- // If not specified, it falls back to the editor font size.
- "markdown_preview_font_size": null,
- // Controls the font family for the markdown preview.
- // If not specified, it falls back to the UI font family.
- "markdown_preview_font_family": null,
- // Controls the font family for code blocks in the markdown preview.
- // If not specified, it falls back to the editor font family.
- "markdown_preview_code_font_family": null
+ "markdown_preview": {
+ // Controls the font size for the markdown preview.
+ // If not specified, it falls back to the editor font size.
+ "font_size": null,
+ // Controls the font family for the markdown preview.
+ // If not specified, it falls back to the UI font family.
+ "font_family": null,
+ // Controls the font family for code blocks in the markdown preview.
+ // If not specified, it falls back to the editor font family.
+ "code_font_family": null
+ }
```
### Font ligatures