logiguard fork: GPUI xdg-activation keyboard-focus serial fix

Single-commit orphan branch: full zed-industries/zed @ 8c74db0 source tree
with a 3-file patch applied (no upstream history).

Patch (crates/gpui_linux/src/linux/wayland/):
  - serial.rs: add SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; add latest_serial_of()
  - window.rs: activate() uses keyboard-enter serial (Mutter focus gate)

Mutter honors window activation only when the token carries the keyboard-
focus serial from wl_keyboard.enter; GPUI used a stale mouse-press serial.
See docs/tray-window-focus-wayland.md in logiguard.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/language_selector/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "language_selector"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/language_selector.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+editor.workspace = true
+file_icons.workspace = true
+fuzzy.workspace = true
+gpui.workspace = true
+language.workspace = true
+open_path_prompt.workspace = true
+picker.workspace = true
+project.workspace = true
+settings.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true
+
+[dev-dependencies]
+editor = { workspace = true, features = ["test-support"] }
+serde_json.workspace = true

crates/language_selector/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/language_selector/src/active_buffer_language.rs

@@ -0,0 +1,98 @@
+use editor::Editor;
+use gpui::{
+    App, Context, Entity, IntoElement, ParentElement, Render, Styled, Subscription, WeakEntity,
+    Window, div,
+};
+use language::LanguageName;
+use settings::Settings as _;
+use ui::{Button, ButtonCommon, Clickable, FluentBuilder, LabelSize, Tooltip};
+use workspace::{HideStatusItem, StatusBarSettings, StatusItemView, Workspace, item::ItemHandle};
+
+use crate::{LanguageSelector, Toggle};
+
+pub struct ActiveBufferLanguage {
+    active_language: Option<Option<LanguageName>>,
+    workspace: WeakEntity<Workspace>,
+    _observe_active_editor: Option<Subscription>,
+}
+
+impl ActiveBufferLanguage {
+    pub fn new(workspace: &Workspace) -> Self {
+        Self {
+            active_language: None,
+            workspace: workspace.weak_handle(),
+            _observe_active_editor: None,
+        }
+    }
+
+    fn update_language(&mut self, editor: Entity<Editor>, _: &mut Window, cx: &mut Context<Self>) {
+        self.active_language = Some(None);
+
+        let editor = editor.read(cx);
+        if let Some(buffer) = editor.active_buffer(cx)
+            && let Some(language) = buffer.read(cx).language()
+        {
+            self.active_language = Some(Some(language.name()));
+        }
+
+        cx.notify();
+    }
+}
+
+impl Render for ActiveBufferLanguage {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        if !StatusBarSettings::get_global(cx).active_language_button {
+            return div().hidden();
+        }
+
+        div().when_some(self.active_language.as_ref(), |el, active_language| {
+            let active_language_text = if let Some(active_language_text) = active_language {
+                active_language_text.to_string()
+            } else {
+                "Unknown".to_string()
+            };
+
+            el.child(
+                Button::new("change-language", active_language_text)
+                    .label_size(LabelSize::Small)
+                    .on_click(cx.listener(|this, _, window, cx| {
+                        if let Some(workspace) = this.workspace.upgrade() {
+                            workspace.update(cx, |workspace, cx| {
+                                LanguageSelector::toggle(workspace, window, cx)
+                            });
+                        }
+                    }))
+                    .tooltip(|_window, cx| Tooltip::for_action("Select Language", &Toggle, cx)),
+            )
+        })
+    }
+}
+
+impl StatusItemView for ActiveBufferLanguage {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn ItemHandle>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(editor) = active_pane_item.and_then(|item| item.downcast::<Editor>()) {
+            self._observe_active_editor =
+                Some(cx.observe_in(&editor, window, Self::update_language));
+            self.update_language(editor, window, cx);
+        } else {
+            self.active_language = None;
+            self._observe_active_editor = None;
+        }
+
+        cx.notify();
+    }
+
+    fn hide_setting(&self, _: &App) -> Option<HideStatusItem> {
+        Some(HideStatusItem::new(|settings| {
+            settings
+                .status_bar
+                .get_or_insert_default()
+                .active_language_button = Some(false);
+        }))
+    }
+}

crates/language_selector/src/language_selector.rs

@@ -0,0 +1,672 @@
+mod active_buffer_language;
+
+pub use active_buffer_language::ActiveBufferLanguage;
+use anyhow::Context as _;
+use editor::Editor;
+use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
+use gpui::{
+    App, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, ParentElement,
+    Render, Styled, TaskExt, WeakEntity, Window, actions,
+};
+use language::{Buffer, LanguageMatcher, LanguageName, LanguageRegistry};
+use open_path_prompt::file_finder_settings::FileFinderSettings;
+use picker::{Picker, PickerDelegate};
+use project::Project;
+use settings::Settings;
+use std::{ops::Not as _, path::Path, sync::Arc};
+use ui::{HighlightedLabel, ListItem, ListItemSpacing, prelude::*};
+use util::ResultExt;
+use workspace::{ModalView, Workspace};
+
+actions!(
+    language_selector,
+    [
+        /// Toggles the language selector modal.
+        Toggle
+    ]
+);
+
+pub fn init(cx: &mut App) {
+    cx.observe_new(LanguageSelector::register).detach();
+}
+
+pub struct LanguageSelector {
+    picker: Entity<Picker<LanguageSelectorDelegate>>,
+}
+
+impl LanguageSelector {
+    fn register(
+        workspace: &mut Workspace,
+        _window: Option<&mut Window>,
+        _: &mut Context<Workspace>,
+    ) {
+        workspace.register_action(move |workspace, _: &Toggle, window, cx| {
+            Self::toggle(workspace, window, cx);
+        });
+    }
+
+    fn toggle(
+        workspace: &mut Workspace,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) -> Option<()> {
+        let registry = workspace.app_state().languages.clone();
+        let buffer = workspace
+            .active_item(cx)?
+            .act_as::<Editor>(cx)?
+            .read(cx)
+            .active_buffer(cx)?;
+        let project = workspace.project().clone();
+
+        workspace.toggle_modal(window, cx, move |window, cx| {
+            LanguageSelector::new(buffer, project, registry, window, cx)
+        });
+        Some(())
+    }
+
+    fn new(
+        buffer: Entity<Buffer>,
+        project: Entity<Project>,
+        language_registry: Arc<LanguageRegistry>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let current_language_name = buffer
+            .read(cx)
+            .language()
+            .map(|language| language.name().as_ref().to_string());
+        let delegate = LanguageSelectorDelegate::new(
+            cx.entity().downgrade(),
+            buffer,
+            project,
+            language_registry,
+            current_language_name,
+        );
+
+        let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx));
+        Self { picker }
+    }
+}
+
+impl Render for LanguageSelector {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .key_context("LanguageSelector")
+            .w(rems(34.))
+            .child(self.picker.clone())
+    }
+}
+
+impl Focusable for LanguageSelector {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.picker.focus_handle(cx)
+    }
+}
+
+impl EventEmitter<DismissEvent> for LanguageSelector {}
+impl ModalView for LanguageSelector {}
+
+pub struct LanguageSelectorDelegate {
+    language_selector: WeakEntity<LanguageSelector>,
+    buffer: Entity<Buffer>,
+    project: Entity<Project>,
+    language_registry: Arc<LanguageRegistry>,
+    candidates: Vec<StringMatchCandidate>,
+    matches: Vec<StringMatch>,
+    selected_index: usize,
+    current_language_candidate_index: Option<usize>,
+}
+
+impl LanguageSelectorDelegate {
+    fn new(
+        language_selector: WeakEntity<LanguageSelector>,
+        buffer: Entity<Buffer>,
+        project: Entity<Project>,
+        language_registry: Arc<LanguageRegistry>,
+        current_language_name: Option<String>,
+    ) -> Self {
+        let candidates = language_registry
+            .language_names()
+            .into_iter()
+            .filter_map(|name| {
+                language_registry
+                    .available_language_for_name(name.as_ref())?
+                    .hidden()
+                    .not()
+                    .then_some(name)
+            })
+            .enumerate()
+            .map(|(candidate_id, name)| StringMatchCandidate::new(candidate_id, name.as_ref()))
+            .collect::<Vec<_>>();
+
+        let current_language_candidate_index = current_language_name.as_ref().and_then(|name| {
+            candidates
+                .iter()
+                .position(|candidate| candidate.string == *name)
+        });
+
+        Self {
+            language_selector,
+            buffer,
+            project,
+            language_registry,
+            candidates,
+            matches: vec![],
+            selected_index: current_language_candidate_index.unwrap_or(0),
+            current_language_candidate_index,
+        }
+    }
+
+    fn language_data_for_match(&self, mat: &StringMatch, cx: &App) -> (String, Option<Icon>) {
+        let mut label = mat.string.clone();
+        let buffer_language = self.buffer.read(cx).language();
+        let need_icon = FileFinderSettings::get_global(cx).file_icons;
+
+        if let Some(buffer_language) = buffer_language
+            .filter(|buffer_language| buffer_language.name().as_ref() == mat.string.as_str())
+        {
+            label.push_str(" (current)");
+            let icon = need_icon
+                .then(|| self.language_icon(&buffer_language.config().matcher, cx))
+                .flatten();
+            (label, icon)
+        } else {
+            let icon = need_icon
+                .then(|| {
+                    let language_name = LanguageName::new(mat.string.as_str());
+                    self.language_registry
+                        .available_language_for_name(language_name.as_ref())
+                        .and_then(|available_language| {
+                            self.language_icon(available_language.matcher(), cx)
+                        })
+                })
+                .flatten();
+            (label, icon)
+        }
+    }
+
+    fn language_icon(&self, matcher: &LanguageMatcher, cx: &App) -> Option<Icon> {
+        matcher
+            .path_suffixes
+            .iter()
+            .find_map(|extension| file_icons::FileIcons::get_icon(Path::new(extension), cx))
+            .map(Icon::from_path)
+            .map(|icon| icon.color(Color::Muted))
+    }
+}
+
+impl PickerDelegate for LanguageSelectorDelegate {
+    type ListItem = ListItem;
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
+        "Select a language…".into()
+    }
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn confirm(&mut self, _: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        if let Some(mat) = self.matches.get(self.selected_index) {
+            let language_name = &self.candidates[mat.candidate_id].string;
+            let language = self.language_registry.language_for_name(language_name);
+            let project = self.project.downgrade();
+            let buffer = self.buffer.downgrade();
+            cx.spawn_in(window, async move |_, cx| {
+                let language = language.await?;
+                let project = project.upgrade().context("project was dropped")?;
+                let buffer = buffer.upgrade().context("buffer was dropped")?;
+                project.update(cx, |project, cx| {
+                    project.set_language_for_buffer(&buffer, language, cx);
+                });
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+        }
+        self.dismissed(window, cx);
+    }
+
+    fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.language_selector
+            .update(cx, |_, cx| cx.emit(DismissEvent))
+            .log_err();
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> gpui::Task<()> {
+        let background = cx.background_executor().clone();
+        let candidates = self.candidates.clone();
+        let query_is_empty = query.is_empty();
+        cx.spawn_in(window, async move |this, cx| {
+            let matches = if query_is_empty {
+                candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, candidate)| StringMatch {
+                        candidate_id: index,
+                        string: candidate.string,
+                        positions: Vec::new(),
+                        score: 0.0,
+                    })
+                    .collect()
+            } else {
+                match_strings(
+                    &candidates,
+                    &query,
+                    false,
+                    true,
+                    100,
+                    &Default::default(),
+                    background,
+                )
+                .await
+            };
+
+            this.update_in(cx, |this, window, cx| {
+                if matches.is_empty() {
+                    this.delegate.matches = matches;
+                    this.delegate.selected_index = 0;
+                    cx.notify();
+                    return;
+                }
+
+                let selected_index = if query_is_empty {
+                    this.delegate
+                        .current_language_candidate_index
+                        .and_then(|current_language_candidate_index| {
+                            matches.iter().position(|mat| {
+                                mat.candidate_id == current_language_candidate_index
+                            })
+                        })
+                        .unwrap_or(0)
+                } else {
+                    0
+                };
+
+                this.delegate.matches = matches;
+                this.set_selected_index(selected_index, None, false, window, cx);
+                cx.notify();
+            })
+            .log_err();
+        })
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let mat = &self.matches.get(ix)?;
+        let (label, language_icon) = self.language_data_for_match(mat, cx);
+        Some(
+            ListItem::new(ix)
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .start_slot::<Icon>(language_icon)
+                .child(HighlightedLabel::new(label, mat.positions.clone())),
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use editor::Editor;
+    use gpui::{TestAppContext, VisualTestContext};
+    use language::{Language, LanguageConfig};
+    use project::{Project, ProjectPath};
+    use serde_json::json;
+    use std::sync::Arc;
+    use util::{path, rel_path::rel_path};
+    use workspace::{AppState, MultiWorkspace, Workspace};
+
+    fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
+        cx.update(|cx| {
+            let app_state = AppState::test(cx);
+            settings::init(cx);
+            super::init(cx);
+            editor::init(cx);
+            app_state
+        })
+    }
+
+    fn register_test_languages(project: &Entity<Project>, cx: &mut VisualTestContext) {
+        project.read_with(cx, |project, _| {
+            let language_registry = project.languages();
+            for (language_name, path_suffix) in [
+                ("C", "c"),
+                ("Go", "go"),
+                ("Ruby", "rb"),
+                ("Rust", "rs"),
+                ("TypeScript", "ts"),
+            ] {
+                language_registry.add(Arc::new(Language::new(
+                    LanguageConfig {
+                        name: language_name.into(),
+                        matcher: LanguageMatcher {
+                            path_suffixes: vec![path_suffix.to_string()],
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    },
+                    None,
+                )));
+            }
+        });
+    }
+
+    async fn open_file_editor(
+        workspace: &Entity<Workspace>,
+        project: &Entity<Project>,
+        file_path: &str,
+        cx: &mut VisualTestContext,
+    ) -> Entity<Editor> {
+        let worktree_id = project.update(cx, |project, cx| {
+            project
+                .worktrees(cx)
+                .next()
+                .expect("project should have a worktree")
+                .read(cx)
+                .id()
+        });
+        let project_path = ProjectPath {
+            worktree_id,
+            path: rel_path(file_path).into(),
+        };
+        let opened_item = workspace
+            .update_in(cx, |workspace, window, cx| {
+                workspace.open_path(project_path, None, true, window, cx)
+            })
+            .await
+            .expect("file should open");
+
+        cx.update(|_, cx| {
+            opened_item
+                .act_as::<Editor>(cx)
+                .expect("opened item should be an editor")
+        })
+    }
+
+    async fn open_empty_editor(
+        workspace: &Entity<Workspace>,
+        project: &Entity<Project>,
+        cx: &mut VisualTestContext,
+    ) -> Entity<Editor> {
+        let editor = open_new_buffer_editor(workspace, project, cx).await;
+        // Ensure the buffer has no language after the editor is created
+        let buffer = editor.read_with(cx, |editor, cx| {
+            editor
+                .active_buffer(cx)
+                .expect("editor should have an active buffer")
+        });
+        buffer.update(cx, |buffer, cx| {
+            buffer.set_language(None, cx);
+        });
+        editor
+    }
+
+    async fn open_new_buffer_editor(
+        workspace: &Entity<Workspace>,
+        project: &Entity<Project>,
+        cx: &mut VisualTestContext,
+    ) -> Entity<Editor> {
+        let create_buffer = project.update(cx, |project, cx| project.create_buffer(None, true, cx));
+        let buffer = create_buffer.await.expect("empty buffer should be created");
+        let editor = cx.new_window_entity(|window, cx| {
+            Editor::for_buffer(buffer.clone(), Some(project.clone()), window, cx)
+        });
+        workspace.update_in(cx, |workspace, window, cx| {
+            workspace.add_item_to_center(Box::new(editor.clone()), window, cx);
+        });
+        editor
+    }
+
+    async fn set_editor_language(
+        project: &Entity<Project>,
+        editor: &Entity<Editor>,
+        language_name: &str,
+        cx: &mut VisualTestContext,
+    ) {
+        let language = project
+            .read_with(cx, |project, _| {
+                project.languages().language_for_name(language_name)
+            })
+            .await
+            .expect("language should exist in registry");
+        editor.update(cx, move |editor, cx| {
+            let buffer = editor
+                .active_buffer(cx)
+                .expect("editor should have an active excerpt");
+            buffer.update(cx, |buffer, cx| {
+                buffer.set_language(Some(language), cx);
+            });
+        });
+    }
+
+    fn active_picker(
+        workspace: &Entity<Workspace>,
+        cx: &mut VisualTestContext,
+    ) -> Entity<Picker<LanguageSelectorDelegate>> {
+        workspace.update(cx, |workspace, cx| {
+            workspace
+                .active_modal::<LanguageSelector>(cx)
+                .expect("language selector should be open")
+                .read(cx)
+                .picker
+                .clone()
+        })
+    }
+
+    fn open_selector(
+        workspace: &Entity<Workspace>,
+        cx: &mut VisualTestContext,
+    ) -> Entity<Picker<LanguageSelectorDelegate>> {
+        cx.dispatch_action(Toggle);
+        cx.run_until_parked();
+        active_picker(workspace, cx)
+    }
+
+    fn close_selector(workspace: &Entity<Workspace>, cx: &mut VisualTestContext) {
+        cx.dispatch_action(Toggle);
+        cx.run_until_parked();
+        workspace.read_with(cx, |workspace, cx| {
+            assert!(
+                workspace.active_modal::<LanguageSelector>(cx).is_none(),
+                "language selector should be closed"
+            );
+        });
+    }
+
+    fn assert_selected_language_for_editor(
+        workspace: &Entity<Workspace>,
+        editor: &Entity<Editor>,
+        expected_language_name: Option<&str>,
+        cx: &mut VisualTestContext,
+    ) {
+        workspace.update_in(cx, |workspace, window, cx| {
+            let was_activated = workspace.activate_item(editor, true, true, window, cx);
+            assert!(
+                was_activated,
+                "editor should be activated before opening the modal"
+            );
+        });
+        cx.run_until_parked();
+
+        let picker = open_selector(workspace, cx);
+        picker.read_with(cx, |picker, _| {
+            let selected_match = picker
+                .delegate
+                .matches
+                .get(picker.delegate.selected_index)
+                .expect("selected index should point to a match");
+            let selected_candidate = picker
+                .delegate
+                .candidates
+                .get(selected_match.candidate_id)
+                .expect("selected match should map to a candidate");
+
+            if let Some(expected_language_name) = expected_language_name {
+                let current_language_candidate_index = picker
+                    .delegate
+                    .current_language_candidate_index
+                    .expect("current language should map to a candidate");
+                assert_eq!(
+                    selected_match.candidate_id,
+                    current_language_candidate_index
+                );
+                assert_eq!(selected_candidate.string, expected_language_name);
+            } else {
+                assert!(picker.delegate.current_language_candidate_index.is_none());
+                assert_eq!(picker.delegate.selected_index, 0);
+            }
+        });
+        close_selector(workspace, cx);
+    }
+
+    #[gpui::test]
+    async fn test_language_selector_selects_current_language_per_active_editor(
+        cx: &mut TestAppContext,
+    ) {
+        let app_state = init_test(cx);
+        app_state
+            .fs
+            .as_fake()
+            .insert_tree(
+                path!("/test"),
+                json!({
+                    "rust_file.rs": "fn main() {}\n",
+                    "typescript_file.ts": "const value = 1;\n",
+                }),
+            )
+            .await;
+
+        let project = Project::test(app_state.fs.clone(), [path!("/test").as_ref()], cx).await;
+        let (multi_workspace, cx) =
+            cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+        let workspace =
+            multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
+        register_test_languages(&project, cx);
+
+        let rust_editor = open_file_editor(&workspace, &project, "rust_file.rs", cx).await;
+        let typescript_editor =
+            open_file_editor(&workspace, &project, "typescript_file.ts", cx).await;
+        let empty_editor = open_empty_editor(&workspace, &project, cx).await;
+
+        set_editor_language(&project, &rust_editor, "Rust", cx).await;
+        set_editor_language(&project, &typescript_editor, "TypeScript", cx).await;
+        cx.run_until_parked();
+
+        assert_selected_language_for_editor(&workspace, &rust_editor, Some("Rust"), cx);
+        assert_selected_language_for_editor(&workspace, &typescript_editor, Some("TypeScript"), cx);
+        // Ensure the empty editor's buffer has no language before asserting
+        let buffer = empty_editor.read_with(cx, |editor, cx| {
+            editor
+                .active_buffer(cx)
+                .expect("editor should have an active excerpt")
+        });
+        buffer.update(cx, |buffer, cx| {
+            buffer.set_language(None, cx);
+        });
+        assert_selected_language_for_editor(&workspace, &empty_editor, None, cx);
+    }
+
+    #[gpui::test]
+    async fn test_language_selector_selects_first_match_after_querying_new_buffer(
+        cx: &mut TestAppContext,
+    ) {
+        let app_state = init_test(cx);
+        app_state
+            .fs
+            .as_fake()
+            .insert_tree(path!("/test"), json!({}))
+            .await;
+
+        let project = Project::test(app_state.fs.clone(), [path!("/test").as_ref()], cx).await;
+        let (multi_workspace, cx) =
+            cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+        let workspace =
+            multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
+        register_test_languages(&project, cx);
+
+        let editor = open_new_buffer_editor(&workspace, &project, cx).await;
+        workspace.update_in(cx, |workspace, window, cx| {
+            let was_activated = workspace.activate_item(&editor, true, true, window, cx);
+            assert!(
+                was_activated,
+                "editor should be activated before opening the modal"
+            );
+        });
+        cx.run_until_parked();
+
+        let picker = open_selector(&workspace, cx);
+        picker.read_with(cx, |picker, _| {
+            let selected_match = picker
+                .delegate
+                .matches
+                .get(picker.delegate.selected_index)
+                .expect("selected index should point to a match");
+            let selected_candidate = picker
+                .delegate
+                .candidates
+                .get(selected_match.candidate_id)
+                .expect("selected match should map to a candidate");
+
+            assert_eq!(selected_candidate.string, "Plain Text");
+            assert!(
+                picker
+                    .delegate
+                    .current_language_candidate_index
+                    .is_some_and(|current_language_candidate_index| {
+                        current_language_candidate_index > 1
+                    }),
+                "test setup should place Plain Text after at least two earlier languages",
+            );
+        });
+
+        picker.update_in(cx, |picker, window, cx| {
+            picker.update_matches("ru".to_string(), window, cx)
+        });
+        cx.run_until_parked();
+
+        picker.read_with(cx, |picker, _| {
+            assert!(
+                picker.delegate.matches.len() > 1,
+                "query should return multiple matches"
+            );
+            assert_eq!(picker.delegate.selected_index, 0);
+
+            let first_match = picker
+                .delegate
+                .matches
+                .first()
+                .expect("query should produce at least one match");
+            let selected_match = picker
+                .delegate
+                .matches
+                .get(picker.delegate.selected_index)
+                .expect("selected index should point to a match");
+
+            assert_eq!(selected_match.candidate_id, first_match.candidate_id);
+        });
+    }
+}