Add Caps Lock support (#30470)

Closes #21700 Release Notes: - Added caps lock support and show a warning if the user is entering an SSH password with Caps Lock enabled ---------

Maxim Zaks committed 1 year ago

Commit 90aa99b1 parent e47c48f16 files · +146 −31Browse files

Unified · Split

16 files

crates/gpui/src/app/test_context.rs +14 −3
crates/gpui/src/interactive.rs +4 −2
crates/gpui/src/platform.rs +1 −0
crates/gpui/src/platform/keystroke.rs +8 −0
crates/gpui/src/platform/linux/platform.rs +8 −0
crates/gpui/src/platform/linux/wayland/client.rs +6 −1
crates/gpui/src/platform/linux/wayland/window.rs +12 −5
crates/gpui/src/platform/linux/x11/client.rs +16 −2
crates/gpui/src/platform/linux/x11/window.rs +11 −0
crates/gpui/src/platform/mac/events.rs +6 −1
crates/gpui/src/platform/mac/window.rs +22 −8
crates/gpui/src/platform/test/window.rs +4 −0
crates/gpui/src/platform/windows/events.rs +8 −0
crates/gpui/src/platform/windows/window.rs +4 −0
crates/gpui/src/window.rs +19 −9
crates/recent_projects/src/ssh_connections.rs +3 −0

crates/gpui/src/app/test_context.rs+14−3

 use crate::{
     Action, AnyView, AnyWindowHandle, App, AppCell, AppContext, AsyncApp, AvailableSpace,
-    BackgroundExecutor, BorrowAppContext, Bounds, ClipboardItem, DrawPhase, Drawable, Element,
+    BackgroundExecutor, BorrowAppContext, Bounds, Capslock, ClipboardItem, DrawPhase, Drawable,
-    Empty, EventEmitter, ForegroundExecutor, Global, InputEvent, Keystroke, Modifiers,
+    Element, Empty, EventEmitter, ForegroundExecutor, Global, InputEvent, Keystroke, Modifiers,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels,
     Platform, Point, Render, Result, Size, Task, TestDispatcher, TestPlatform,
     TestScreenCaptureSource, TestWindow, TextSystem, VisualContext, Window, WindowBounds,
     /// Simulate a modifiers changed event
     pub fn simulate_modifiers_change(&mut self, modifiers: Modifiers) {
-        self.simulate_event(ModifiersChangedEvent { modifiers })
+        self.simulate_event(ModifiersChangedEvent {
+            modifiers,
+            capslock: Capslock { on: false },
+        })
+    }
+    /// Simulate a capslock changed event
+    pub fn simulate_capslock_change(&mut self, on: bool) {
+        self.simulate_event(ModifiersChangedEvent {
+            modifiers: Modifiers::none(),
+            capslock: Capslock { on },
+        })
     }
     /// Simulates the user resizing the window to the new size.

crates/gpui/src/interactive.rs+4−2

 use crate::{
-    Context, Empty, IntoElement, Keystroke, Modifiers, Pixels, Point, Render, Window, point,
+    Capslock, Context, Empty, IntoElement, Keystroke, Modifiers, Pixels, Point, Render, Window,
-    seal::Sealed,
+    point, seal::Sealed,
 };
 use smallvec::SmallVec;
 use std::{any::Any, fmt::Debug, ops::Deref, path::PathBuf};
 pub struct ModifiersChangedEvent {
     /// The new state of the modifier keys
     pub modifiers: Modifiers,
+    /// The new state of the capslock key
+    pub capslock: Capslock,
 }
 impl Sealed for ModifiersChangedEvent {}

crates/gpui/src/platform.rs+1−0

@@ -415,6 +415,7 @@ pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle { · 414 unmodified lines
415	fn display(&self) -> Option<Rc<dyn PlatformDisplay>>;	415	fn display(&self) -> Option<Rc<dyn PlatformDisplay>>;
416	fn mouse_position(&self) -> Point<Pixels>;	416	fn mouse_position(&self) -> Point<Pixels>;
417	fn modifiers(&self) -> Modifiers;	417	fn modifiers(&self) -> Modifiers;
		418	fn capslock(&self) -> Capslock;
418	fn set_input_handler(&mut self, input_handler: PlatformInputHandler);	419	fn set_input_handler(&mut self, input_handler: PlatformInputHandler);
419	fn take_input_handler(&mut self) -> Option<PlatformInputHandler>;	420	fn take_input_handler(&mut self) -> Option<PlatformInputHandler>;
420	fn prompt(	421	fn prompt(

crates/gpui/src/platform/keystroke.rs+8−0

@@ -538,3 +538,11 @@ impl Modifiers { · 537 unmodified lines
538	&& (other.function \|\| !self.function)	538	&& (other.function \|\| !self.function)
539	}	539	}
540	}	540	}
		541
		542	/// The state of the capslock key at some point in time
		543	#[derive(Copy, Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize, Hash, JsonSchema)]
		544	pub struct Capslock {
		545	/// The capslock key is on
		546	#[serde(default)]
		547	pub on: bool,
		548	}

crates/gpui/src/platform/linux/platform.rs+8−0

@@ -873,6 +873,14 @@ impl crate::Modifiers { · 872 unmodified lines
873	}	873	}
874	}	874	}
875		875
		876	#[cfg(any(feature = "wayland", feature = "x11"))]
		877	impl crate::Capslock {
		878	pub(super) fn from_xkb(keymap_state: &State) -> Self {
		879	let on = keymap_state.mod_name_is_active(xkb::MOD_NAME_CAPS, xkb::STATE_MODS_EFFECTIVE);
		880	Self { on }
		881	}
		882	}
		883
876	#[cfg(test)]	884	#[cfg(test)]
877	mod tests {	885	mod tests {
878	use super::*;	886	use super::*;

crates/gpui/src/platform/linux/wayland/client.rs+6−1

 use crate::platform::{PlatformWindow, blade::BladeContext};
 use crate::{
-    AnyWindowHandle, Bounds, CursorStyle, DOUBLE_CLICK_INTERVAL, DevicePixels, DisplayId,
+    AnyWindowHandle, Bounds, Capslock, CursorStyle, DOUBLE_CLICK_INTERVAL, DevicePixels, DisplayId,
     FileDropEvent, ForegroundExecutor, KeyDownEvent, KeyUpEvent, Keystroke, LinuxCommon,
     LinuxKeyboardLayout, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent,
     MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels, PlatformDisplay,
     click: ClickState,
     repeat: KeyRepeat,
     pub modifiers: Modifiers,
+    pub capslock: Capslock,
     axis_source: AxisSource,
     pub mouse_location: Option<Point<Pixels>>,
     continuous_scroll_delta: Option<Point<Pixels>>,
                 function: false,
                 platform: false,
             },
+            capslock: Capslock { on: false },
             scroll_event_received: false,
             axis_source: AxisSource::Wheel,
             mouse_location: None,
                     keymap_state.serialize_layout(xkbcommon::xkb::STATE_LAYOUT_EFFECTIVE);
                 keymap_state.update_mask(mods_depressed, mods_latched, mods_locked, 0, 0, group);
                 state.modifiers = Modifiers::from_xkb(keymap_state);
+                let keymap_state = state.keymap_state.as_mut().unwrap();
+                state.capslock = Capslock::from_xkb(keymap_state);
                 let input = PlatformInput::ModifiersChanged(ModifiersChangedEvent {
                     modifiers: state.modifiers,
+                    capslock: state.capslock,
                 });
                 drop(state);

crates/gpui/src/platform/linux/wayland/window.rs+12−5

 use wayland_protocols::xdg::shell::client::xdg_toplevel::{self};
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur;
-use crate::platform::{
-    PlatformAtlas, PlatformInputHandler, PlatformWindow,
-    blade::{BladeContext, BladeRenderer, BladeSurfaceConfig},
-    linux::wayland::{display::WaylandDisplay, serial::SerialKind},
-};
 use crate::scene::Scene;
 use crate::{
     AnyWindowHandle, Bounds, Decorations, Globals, GpuSpecs, Modifiers, Output, Pixels,
     WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowControls, WindowDecorations,
     WindowParams, px, size,
 };
+use crate::{
+    Capslock,
+    platform::{
+        PlatformAtlas, PlatformInputHandler, PlatformWindow,
+        blade::{BladeContext, BladeRenderer, BladeSurfaceConfig},
+        linux::wayland::{display::WaylandDisplay, serial::SerialKind},
+    },
+};
 #[derive(Default)]
 pub(crate) struct Callbacks {
         self.borrow().client.get_client().borrow().modifiers
     }
+    fn capslock(&self) -> Capslock {
+        self.borrow().client.get_client().borrow().capslock
+    }
     fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
         self.borrow_mut().input_handler = Some(input_handler);
     }

crates/gpui/src/platform/linux/x11/client.rs+16−2

+use crate::Capslock;
 use core::str;
 use std::{
     cell::RefCell,
     pub(crate) ximc: Option<X11rbClient<Rc<XCBConnection>>>,
     pub(crate) xim_handler: Option<XimHandler>,
     pub modifiers: Modifiers,
+    pub capslock: Capslock,
     // TODO: Can the other updates to `modifiers` be removed so that this is unnecessary?
+    // capslock logic was done analog to modifiers
     pub last_modifiers_changed_event: Modifiers,
+    pub last_capslock_changed_event: Capslock,
     pub(crate) compose_state: Option<xkbc::compose::State>,
     pub(crate) pre_edit_text: Option<String>,
         X11Client(Rc::new(RefCell::new(X11ClientState {
             modifiers: Modifiers::default(),
+            capslock: Capslock::default(),
             last_modifiers_changed_event: Modifiers::default(),
+            last_capslock_changed_event: Capslock::default(),
             event_loop: Some(event_loop),
             loop_handle: handle,
             common,
                 };
                 let modifiers = Modifiers::from_xkb(&state.xkb);
-                if state.last_modifiers_changed_event == modifiers {
+                let capslock = Capslock::from_xkb(&state.xkb);
+                if state.last_modifiers_changed_event == modifiers
+                    && state.last_capslock_changed_event == capslock
+                {
                     drop(state);
                 } else {
                     let focused_window_id = state.keyboard_focused_window?;
                     state.modifiers = modifiers;
                     state.last_modifiers_changed_event = modifiers;
+                    state.capslock = capslock;
+                    state.last_capslock_changed_event = capslock;
                     drop(state);
                     let focused_window = self.get_window(focused_window_id)?;
                     focused_window.handle_input(PlatformInput::ModifiersChanged(
-                        ModifiersChangedEvent { modifiers },
+                        ModifiersChangedEvent {
+                            modifiers,
+                            capslock,
+                        },
                     ));
                 }

crates/gpui/src/platform/linux/x11/window.rs+11−0

@@ -1215,6 +1215,17 @@ impl PlatformWindow for X11Window { · 1214 unmodified lines
1215	.unwrap_or_default()	1215	.unwrap_or_default()
1216	}	1216	}
1217		1217
		1218	fn capslock(&self) -> crate::Capslock {
		1219	self.0
		1220	.state
		1221	.borrow()
		1222	.client
		1223	.0
		1224	.upgrade()
		1225	.map(\|ref_cell\| ref_cell.borrow().capslock)
		1226	.unwrap_or_default()
		1227	}
		1228
1218	fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {	1229	fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
1219	self.0.state.borrow_mut().input_handler = Some(input_handler);	1230	self.0.state.borrow_mut().input_handler = Some(input_handler);
1220	}	1231	}

crates/gpui/src/platform/mac/events.rs+6−1

 use crate::{
-    KeyDownEvent, KeyUpEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
+    Capslock, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
     MouseDownEvent, MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels,
     PlatformInput, ScrollDelta, ScrollWheelEvent, TouchPhase,
     platform::mac::{
                 NSEventType::NSFlagsChanged => {
                     Some(Self::ModifiersChanged(ModifiersChangedEvent {
                         modifiers: read_modifiers(native_event),
+                        capslock: Capslock {
+                            on: native_event
+                                .modifierFlags()
+                                .contains(NSEventModifierFlags::NSAlphaShiftKeyMask),
+                        },
                     }))
                 }
                 NSEventType::NSKeyDown => Some(Self::KeyDown(KeyDownEvent {

crates/gpui/src/platform/mac/window.rs+22−8

 use super::{BoolExt, MacDisplay, NSRange, NSStringExt, ns_string, renderer};
 use crate::{
-    AnyWindowHandle, Bounds, DisplayLink, ExternalPaths, FileDropEvent, ForegroundExecutor,
+    AnyWindowHandle, Bounds, Capslock, DisplayLink, ExternalPaths, FileDropEvent,
-    KeyDownEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent,
+    ForegroundExecutor, KeyDownEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
-    MouseMoveEvent, MouseUpEvent, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,
+    MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, PlatformAtlas, PlatformDisplay,
-    PlatformWindow, Point, PromptButton, PromptLevel, RequestFrameOptions, ScaledPixels, Size,
+    PlatformInput, PlatformWindow, Point, PromptButton, PromptLevel, RequestFrameOptions,
-    Timer, WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControlArea,
+    ScaledPixels, Size, Timer, WindowAppearance, WindowBackgroundAppearance, WindowBounds,
-    WindowKind, WindowParams, platform::PlatformInputHandler, point, px, size,
+    WindowControlArea, WindowKind, WindowParams, platform::PlatformInputHandler, point, px, size,
 };
 use block::ConcreteBlock;
 use cocoa::{
         }
     }
+    fn capslock(&self) -> Capslock {
+        unsafe {
+            let modifiers: NSEventModifierFlags = msg_send![class!(NSEvent), modifierFlags];
+            Capslock {
+                on: modifiers.contains(NSEventModifierFlags::NSAlphaShiftKeyMask),
+            }
+        }
+    }
     fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
         self.0.as_ref().lock().input_handler = Some(input_handler);
     }
                 lock.synthetic_drag_counter += 1;
             }
-            PlatformInput::ModifiersChanged(ModifiersChangedEvent { modifiers }) => {
+            PlatformInput::ModifiersChanged(ModifiersChangedEvent {
+                modifiers,
+                capslock,
+            }) => {
                 // Only raise modifiers changed event when they have actually changed
                 if let Some(PlatformInput::ModifiersChanged(ModifiersChangedEvent {
                     modifiers: prev_modifiers,
+                    capslock: prev_capslock,
                 })) = &lock.previous_modifiers_changed_event
                 {
-                    if prev_modifiers == modifiers {
+                    if prev_modifiers == modifiers && prev_capslock == capslock {
                         return;
                     }
                 }

crates/gpui/src/platform/test/window.rs+4−0

         crate::Modifiers::default()
     }
+    fn capslock(&self) -> crate::Capslock {
+        crate::Capslock::default()
+    }
     fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
         self.0.lock().input_handler = Some(input_handler);
     }

crates/gpui/src/platform/windows/events.rs+8−0

 {
     let virtual_key = VIRTUAL_KEY(wparam.loword());
     let mut modifiers = current_modifiers();
+    let capslock = current_capslock();
     match virtual_key {
         VK_SHIFT | VK_CONTROL | VK_MENU | VK_LWIN | VK_RWIN => {
             state.last_reported_modifiers = Some(modifiers);
             Some(PlatformInput::ModifiersChanged(ModifiersChangedEvent {
                 modifiers,
+                capslock,
             }))
         }
         vkey => {
     }
 }
+#[inline]
+pub(crate) fn current_capslock() -> Capslock {
+    let on = unsafe { GetKeyState(VK_CAPITAL.0 as i32) & 1 } > 0;
+    Capslock { on: on }
+}
 fn get_client_area_insets(
     handle: HWND,
     is_maximized: bool,

crates/gpui/src/platform/windows/window.rs+4−0

         current_modifiers()
     }
+    fn capslock(&self) -> Capslock {
+        current_capslock()
+    }
     fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
         self.0.state.borrow_mut().input_handler = Some(input_handler);
     }

crates/gpui/src/window.rs+19−9

 use crate::Inspector;
 use crate::{
     Action, AnyDrag, AnyElement, AnyImageCache, AnyTooltip, AnyView, App, AppContext, Arena, Asset,
-    AsyncWindowContext, AvailableSpace, Background, BorderStyle, Bounds, BoxShadow, Context,
+    AsyncWindowContext, AvailableSpace, Background, BorderStyle, Bounds, BoxShadow, Capslock,
-    Corners, CursorStyle, Decorations, DevicePixels, DispatchActionListener, DispatchNodeId,
+    Context, Corners, CursorStyle, Decorations, DevicePixels, DispatchActionListener,
-    DispatchTree, DisplayId, Edges, Effect, Entity, EntityId, EventEmitter, FileDropEvent, FontId,
+    DispatchNodeId, DispatchTree, DisplayId, Edges, Effect, Entity, EntityId, EventEmitter,
-    Global, GlobalElementId, GlyphId, GpuSpecs, Hsla, InputHandler, IsZero, KeyBinding, KeyContext,
+    FileDropEvent, FontId, Global, GlobalElementId, GlyphId, GpuSpecs, Hsla, InputHandler, IsZero,
-    KeyDownEvent, KeyEvent, Keystroke, KeystrokeEvent, LayoutId, LineLayoutIndex, Modifiers,
+    KeyBinding, KeyContext, KeyDownEvent, KeyEvent, Keystroke, KeystrokeEvent, LayoutId,
-    ModifiersChangedEvent, MonochromeSprite, MouseButton, MouseEvent, MouseMoveEvent, MouseUpEvent,
+    LineLayoutIndex, Modifiers, ModifiersChangedEvent, MonochromeSprite, MouseButton, MouseEvent,
-    Path, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler,
+    MouseMoveEvent, MouseUpEvent, Path, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,
-    PlatformWindow, Point, PolychromeSprite, PromptButton, PromptLevel, Quad, Render,
+    PlatformInputHandler, PlatformWindow, Point, PolychromeSprite, PromptButton, PromptLevel, Quad,
-    RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, Replay, ResizeEdge,
+    Render, RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams, Replay, ResizeEdge,
     SMOOTH_SVG_SCALE_FACTOR, SUBPIXEL_VARIANTS, ScaledPixels, Scene, Shadow, SharedString, Size,
     StrikethroughStyle, Style, SubscriberSet, Subscription, TaffyLayoutEngine, Task, TextStyle,
     TextStyleRefinement, TransformationMatrix, Underline, UnderlineStyle, WindowAppearance,
     mouse_position: Point<Pixels>,
     mouse_hit_test: HitTest,
     modifiers: Modifiers,
+    capslock: Capslock,
     scale_factor: f32,
     pub(crate) bounds_observers: SubscriberSet<(), AnyObserver>,
     appearance: WindowAppearance,
         let sprite_atlas = platform_window.sprite_atlas();
         let mouse_position = platform_window.mouse_position();
         let modifiers = platform_window.modifiers();
+        let capslock = platform_window.capslock();
         let content_size = platform_window.content_size();
         let scale_factor = platform_window.scale_factor();
         let appearance = platform_window.appearance();
                     .update(&mut cx, |_, window, cx| {
                         window.active.set(active);
                         window.modifiers = window.platform_window.modifiers();
+                        window.capslock = window.platform_window.capslock();
                         window
                             .activation_observers
                             .clone()
             mouse_position,
             mouse_hit_test: HitTest::default(),
             modifiers,
+            capslock,
             scale_factor,
             bounds_observers: SubscriberSet::new(),
             appearance,
         self.modifiers
     }
+    /// The current state of the keyboard's capslock
+    pub fn capslock(&self) -> Capslock {
+        self.capslock
+    }
     fn complete_frame(&self) {
         self.platform_window.completed_frame();
     }
             }
             PlatformInput::ModifiersChanged(modifiers_changed) => {
                 self.modifiers = modifiers_changed.modifiers;
+                self.capslock = modifiers_changed.capslock;
                 PlatformInput::ModifiersChanged(modifiers_changed)
             }
             PlatformInput::ScrollWheel(scroll_wheel) => {

crates/recent_projects/src/ssh_connections.rs+3−0

                         .child(MarkdownElement::new(prompt.0.clone(), markdown_style))
                         .child(self.editor.clone()),
                 )
+                .when(window.capslock().on, |el| {
+                    el.child(Label::new("⚠️ ⇪ is on"))
+                })
             })
     }
 }