logiguard fork v3: full patch set on verified 8c74db0 tree

Includes prior-session patches (carry forward so the app compiles):
  - crates/gpui/build.rs: cross-compile manifest fix
  - crates/gpui/src/platform.rs: PlatformWindow::activate_with_token trait method
  - crates/gpui/src/window.rs: Window::activate_with_token public API
  - crates/gpui_linux/src/linux/wayland/window.rs: WaylandWindow::activate_with_token + activate() keyboard-serial fix

Plus the focus-serial fix:
  - serial.rs: SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; latest_serial_of()

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

crates/encoding_selector/src/active_buffer_encoding.rs

@@ -0,0 +1,143 @@
+use crate::{EncodingSelector, Toggle};
+
+use editor::Editor;
+use encoding_rs::{Encoding, UTF_8};
+use gpui::{
+    App, Context, Entity, IntoElement, ParentElement, Render, Styled, Subscription, WeakEntity,
+    Window, div,
+};
+use project::Project;
+use ui::{Button, ButtonCommon, Clickable, LabelSize, Tooltip};
+use workspace::{
+    EncodingDisplayOptions, HideStatusItem, StatusBarSettings, StatusItemView, Workspace,
+    item::{ItemHandle, Settings},
+};
+
+pub struct ActiveBufferEncoding {
+    active_encoding: Option<&'static Encoding>,
+    workspace: WeakEntity<Workspace>,
+    project: Entity<Project>,
+    _observe_active_editor: Option<Subscription>,
+    has_bom: bool,
+    is_dirty: bool,
+    is_shared: bool,
+    is_via_remote_server: bool,
+}
+
+impl ActiveBufferEncoding {
+    pub fn new(workspace: &Workspace) -> Self {
+        Self {
+            active_encoding: None,
+            workspace: workspace.weak_handle(),
+            project: workspace.project().clone(),
+            _observe_active_editor: None,
+            has_bom: false,
+            is_dirty: false,
+            is_shared: false,
+            is_via_remote_server: false,
+        }
+    }
+
+    fn update_encoding(&mut self, editor: Entity<Editor>, _: &mut Window, cx: &mut Context<Self>) {
+        self.active_encoding = None;
+        self.has_bom = false;
+        self.is_dirty = false;
+
+        let project = self.project.read(cx);
+        self.is_shared = project.is_shared();
+        self.is_via_remote_server = project.is_via_remote_server();
+
+        if let Some(buffer) = editor.read(cx).active_buffer(cx) {
+            let buffer = buffer.read(cx);
+            self.active_encoding = Some(buffer.encoding());
+            self.has_bom = buffer.has_bom();
+            self.is_dirty = buffer.is_dirty();
+        }
+
+        cx.notify();
+    }
+}
+
+impl Render for ActiveBufferEncoding {
+    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let Some(active_encoding) = self.active_encoding else {
+            return div().hidden();
+        };
+
+        let display_option = StatusBarSettings::get_global(cx).active_encoding_button;
+        let is_utf8 = active_encoding == UTF_8;
+        if !display_option.should_show(is_utf8, self.has_bom) {
+            return div().hidden();
+        }
+
+        let mut text = active_encoding.name().to_string();
+        if self.has_bom {
+            text.push_str(" (BOM)");
+        }
+
+        let (disabled, tooltip_text) = if self.is_dirty {
+            (true, "Save file to change encoding")
+        } else if self.is_shared {
+            (true, "Cannot change encoding during collaboration")
+        } else if self.is_via_remote_server {
+            (true, "Cannot change encoding of remote server file")
+        } else {
+            (false, "Reopen with Encoding")
+        };
+
+        div().child(
+            Button::new("change-encoding", text)
+                .label_size(LabelSize::Small)
+                .on_click(cx.listener(move |this, _, window, cx| {
+                    if disabled {
+                        return;
+                    }
+                    if let Some(workspace) = this.workspace.upgrade() {
+                        workspace.update(cx, |workspace, cx| {
+                            EncodingSelector::toggle(workspace, window, cx)
+                        });
+                    }
+                }))
+                .tooltip(move |_window, cx| {
+                    if disabled {
+                        Tooltip::text(tooltip_text)(_window, cx)
+                    } else {
+                        Tooltip::for_action(tooltip_text, &Toggle, cx)
+                    }
+                }),
+        )
+    }
+}
+
+impl StatusItemView for ActiveBufferEncoding {
+    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_encoding));
+            self.update_encoding(editor, window, cx);
+        } else {
+            self.active_encoding = None;
+            self.has_bom = false;
+            self.is_dirty = false;
+            self.is_shared = false;
+            self.is_via_remote_server = false;
+            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_encoding_button = Some(EncodingDisplayOptions::Disabled);
+        }))
+    }
+}