Detailed changes
@@ -42,7 +42,7 @@ use gpui::{
action, actions, div, point, px, relative, rems, size, uniform_list, AnyElement, AppContext,
AsyncWindowContext, BackgroundExecutor, Bounds, ClipboardItem, Component, Context,
EventEmitter, FocusHandle, FontFeatures, FontStyle, FontWeight, HighlightStyle, Hsla,
- InputHandler, KeyBindingContext, Model, MouseButton, ParentElement, Pixels, Render,
+ InputHandler, KeyContext, Model, MouseButton, ParentElement, Pixels, Render,
StatelessInteractive, Styled, Subscription, Task, TextStyle, UniformListScrollHandle, View,
ViewContext, VisualContext, WeakView, WindowContext,
};
@@ -646,7 +646,7 @@ pub struct Editor {
collapse_matches: bool,
autoindent_mode: Option<AutoindentMode>,
workspace: Option<(WeakView<Workspace>, i64)>,
- keymap_context_layers: BTreeMap<TypeId, KeyBindingContext>,
+ keymap_context_layers: BTreeMap<TypeId, KeyContext>,
input_enabled: bool,
read_only: bool,
leader_peer_id: Option<PeerId>,
@@ -1980,8 +1980,8 @@ impl Editor {
this
}
- fn dispatch_context(&self, cx: &AppContext) -> KeyBindingContext {
- let mut dispatch_context = KeyBindingContext::default();
+ fn dispatch_context(&self, cx: &AppContext) -> KeyContext {
+ let mut dispatch_context = KeyContext::default();
dispatch_context.add("Editor");
let mode = match self.mode {
EditorMode::SingleLine => "single_line",
@@ -18,10 +18,9 @@ use gpui::{
black, hsla, point, px, relative, size, transparent_black, Action, AnyElement, AvailableSpace,
BorrowAppContext, BorrowWindow, Bounds, ContentMask, Corners, DispatchPhase, Edges, Element,
ElementId, ElementInputHandler, Entity, FocusHandle, GlobalElementId, Hsla, InputHandler,
- KeyBindingContext, KeyDownEvent, KeyListener, KeyMatch, Line, LineLayout, Modifiers,
- MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, ScrollWheelEvent,
- ShapedGlyph, Size, Style, TextRun, TextStyle, TextSystem, ViewContext, WindowContext,
- WrappedLineLayout,
+ KeyContext, KeyDownEvent, KeyListener, KeyMatch, Line, LineLayout, Modifiers, MouseButton,
+ MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, ScrollWheelEvent, ShapedGlyph, Size,
+ Style, TextRun, TextStyle, TextSystem, ViewContext, WindowContext, WrappedLineLayout,
};
use itertools::Itertools;
use language::language_settings::ShowWhitespaceSetting;
@@ -2457,11 +2456,11 @@ impl Element<Editor> for EditorElement {
let dispatch_context = editor.dispatch_context(cx);
cx.with_element_id(cx.view().entity_id(), |global_id, cx| {
- cx.with_key_dispatch_context(dispatch_context, |cx| {
- cx.with_key_listeners(build_key_listeners(global_id), |cx| {
- cx.with_focus(editor.focus_handle.clone(), |_| {})
- });
- })
+ cx.with_key_dispatch(
+ dispatch_context,
+ Some(editor.focus_handle.clone()),
+ |_, _| {},
+ )
});
}
@@ -4165,7 +4164,7 @@ fn build_key_listener<T: 'static>(
listener: impl Fn(
&mut Editor,
&T,
- &[&KeyBindingContext],
+ &[&KeyContext],
DispatchPhase,
&mut ViewContext<Editor>,
) -> Option<Box<dyn Action>>
@@ -1,225 +0,0 @@
-use crate::{
- Action, DispatchPhase, FocusId, KeyBindingContext, KeyDownEvent, KeyMatch, Keymap,
- KeystrokeMatcher, WindowContext,
-};
-use collections::HashMap;
-use parking_lot::Mutex;
-use smallvec::SmallVec;
-use std::{any::Any, sync::Arc};
-
-// trait KeyListener -> FnMut(&E, &mut V, &mut ViewContext<V>)
-type AnyKeyListener = Box<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>;
-type AnyActionListener = Box<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub struct DispatchNodeId(usize);
-
-pub struct DispatchTree {
- node_stack: Vec<DispatchNodeId>,
- context_stack: Vec<KeyBindingContext>,
- nodes: Vec<DispatchNode>,
- focused: Option<FocusId>,
- focusable_node_ids: HashMap<FocusId, DispatchNodeId>,
- keystroke_matchers: HashMap<SmallVec<[KeyBindingContext; 4]>, KeystrokeMatcher>,
- keymap: Arc<Mutex<Keymap>>,
-}
-
-#[derive(Default)]
-pub struct DispatchNode {
- key_listeners: SmallVec<[AnyKeyListener; 2]>,
- action_listeners: SmallVec<[AnyActionListener; 16]>,
- context: KeyBindingContext,
- parent: Option<DispatchNodeId>,
-}
-
-impl DispatchTree {
- pub fn clear(&mut self) {
- self.node_stack.clear();
- self.nodes.clear();
- }
-
- pub fn push_node(&mut self, context: Option<KeyBindingContext>, old_tree: &mut Self) {
- let parent = self.node_stack.last().copied();
- let node_id = DispatchNodeId(self.nodes.len());
- self.nodes.push(DispatchNode {
- parent,
- ..Default::default()
- });
- self.node_stack.push(node_id);
- if let Some(context) = context {
- self.context_stack.push(context);
- if let Some((context_stack, matcher)) = old_tree
- .keystroke_matchers
- .remove_entry(self.context_stack.as_slice())
- {
- self.keystroke_matchers.insert(context_stack, matcher);
- }
- }
- }
-
- pub fn pop_node(&mut self) -> DispatchNodeId {
- self.node_stack.pop().unwrap()
- }
-
- pub fn on_key_event(&mut self, listener: AnyKeyListener) {
- self.active_node().key_listeners.push(listener);
- }
-
- pub fn on_action(&mut self, listener: AnyActionListener) {
- self.active_node().action_listeners.push(listener);
- }
-
- pub fn make_focusable(&mut self, focus_id: FocusId) {
- self.focusable_node_ids
- .insert(focus_id, self.active_node_id());
- }
-
- pub fn set_focus(&mut self, focus_id: Option<FocusId>) {
- self.focused = focus_id;
- }
-
- pub fn active_node(&mut self) -> &mut DispatchNode {
- let node_id = self.active_node_id();
- &mut self.nodes[node_id.0]
- }
-
- fn active_node_id(&self) -> DispatchNodeId {
- *self.node_stack.last().unwrap()
- }
-
- /// Returns the DispatchNodeIds from the root of the tree to the given target node id.
- fn dispatch_path(&self, target: DispatchNodeId) -> SmallVec<[DispatchNodeId; 32]> {
- let mut dispatch_path: SmallVec<[DispatchNodeId; 32]> = SmallVec::new();
- let mut current_node_id = Some(target);
- while let Some(node_id) = current_node_id {
- dispatch_path.push(node_id);
- current_node_id = self.nodes[node_id.0].parent;
- }
- dispatch_path.reverse(); // Reverse the path so it goes from the root to the focused node.
- dispatch_path
- }
-
- pub fn dispatch_key(&mut self, event: &dyn Any, cx: &mut WindowContext) {
- if let Some(focused_node_id) = self
- .focused
- .and_then(|focus_id| self.focusable_node_ids.get(&focus_id))
- .copied()
- {
- self.dispatch_key_on_node(focused_node_id, event, cx);
- }
- }
-
- fn dispatch_key_on_node(
- &mut self,
- node_id: DispatchNodeId,
- event: &dyn Any,
- cx: &mut WindowContext,
- ) {
- let dispatch_path = self.dispatch_path(node_id);
-
- // Capture phase
- self.context_stack.clear();
- cx.propagate_event = true;
- for node_id in &dispatch_path {
- let node = &self.nodes[node_id.0];
- if !node.context.is_empty() {
- self.context_stack.push(node.context.clone());
- }
-
- for key_listener in &node.key_listeners {
- key_listener(event, DispatchPhase::Capture, cx);
- if !cx.propagate_event {
- return;
- }
- }
- }
-
- // Bubble phase
- for node_id in dispatch_path.iter().rev() {
- let node = &self.nodes[node_id.0];
-
- // Handle low level key events
- for key_listener in &node.key_listeners {
- key_listener(event, DispatchPhase::Bubble, cx);
- if !cx.propagate_event {
- return;
- }
- }
-
- // Match keystrokes
- if !node.context.is_empty() {
- if let Some(key_down_event) = event.downcast_ref::<KeyDownEvent>() {
- if !self
- .keystroke_matchers
- .contains_key(self.context_stack.as_slice())
- {
- let keystroke_contexts = self.context_stack.iter().cloned().collect();
- self.keystroke_matchers.insert(
- keystroke_contexts,
- KeystrokeMatcher::new(self.keymap.clone()),
- );
- }
-
- if let Some(keystroke_matcher) = self
- .keystroke_matchers
- .get_mut(self.context_stack.as_slice())
- {
- if let KeyMatch::Some(action) = keystroke_matcher.match_keystroke(
- &key_down_event.keystroke,
- self.context_stack.as_slice(),
- ) {
- self.dispatch_action_on_node(*node_id, action, cx);
- if !cx.propagate_event {
- return;
- }
- }
- }
- }
-
- self.context_stack.pop();
- }
- }
- }
-
- pub fn dispatch_action(&self, action: Box<dyn Action>, cx: &mut WindowContext) {
- if let Some(focused_node_id) = self
- .focused
- .and_then(|focus_id| self.focusable_node_ids.get(&focus_id))
- .copied()
- {
- self.dispatch_action_on_node(focused_node_id, action, cx);
- }
- }
-
- fn dispatch_action_on_node(
- &self,
- node_id: DispatchNodeId,
- action: Box<dyn Action>,
- cx: &mut WindowContext,
- ) {
- let dispatch_path = self.dispatch_path(node_id);
-
- // Capture phase
- for node_id in &dispatch_path {
- let node = &self.nodes[node_id.0];
- for action_listener in &node.action_listeners {
- action_listener(&action, DispatchPhase::Capture, cx);
- if !cx.propagate_event {
- return;
- }
- }
- }
-
- // Bubble phase
- for node_id in dispatch_path.iter().rev() {
- let node = &self.nodes[node_id.0];
- for action_listener in &node.action_listeners {
- cx.propagate_event = false; // Actions stop propagation by default during the bubble phase
- action_listener(&action, DispatchPhase::Capture, cx);
- if !cx.propagate_event {
- return;
- }
- }
- }
- }
-}
@@ -1,29 +1,33 @@
+use std::fmt::Debug;
+
use crate::{
- point, AnyElement, BorrowWindow, Bounds, Component, Element, ElementFocus, ElementId,
- ElementInteractivity, FocusDisabled, FocusEnabled, FocusHandle, FocusListeners, Focusable,
- GlobalElementId, GroupBounds, InteractiveElementState, LayoutId, Overflow, ParentElement,
- Pixels, Point, SharedString, StatefulInteractive, StatefulInteractivity, StatelessInteractive,
- StatelessInteractivity, Style, StyleRefinement, Styled, ViewContext, Visibility,
+ point, AnyElement, BorrowWindow, Bounds, Component, Element, ElementId, ElementInteractivity,
+ FocusHandle, FocusListeners, Focusable, FocusableKeyDispatch, GlobalElementId, GroupBounds,
+ InteractiveElementState, KeyContext, KeyDispatch, LayoutId, NonFocusableKeyDispatch, Overflow,
+ ParentElement, Pixels, Point, SharedString, StatefulInteractive, StatefulInteractivity,
+ StatelessInteractive, StatelessInteractivity, Style, StyleRefinement, Styled, ViewContext,
+ Visibility,
};
use refineable::Refineable;
use smallvec::SmallVec;
+use util::ResultExt;
pub struct Div<
V: 'static,
I: ElementInteractivity<V> = StatelessInteractivity<V>,
- F: ElementFocus<V> = FocusDisabled,
+ K: KeyDispatch<V> = NonFocusableKeyDispatch,
> {
interactivity: I,
- focus: F,
+ key_dispatch: K,
children: SmallVec<[AnyElement<V>; 2]>,
group: Option<SharedString>,
base_style: StyleRefinement,
}
-pub fn div<V: 'static>() -> Div<V, StatelessInteractivity<V>, FocusDisabled> {
+pub fn div<V: 'static>() -> Div<V, StatelessInteractivity<V>, NonFocusableKeyDispatch> {
Div {
interactivity: StatelessInteractivity::default(),
- focus: FocusDisabled,
+ key_dispatch: NonFocusableKeyDispatch::default(),
children: SmallVec::new(),
group: None,
base_style: StyleRefinement::default(),
@@ -33,12 +37,12 @@ pub fn div<V: 'static>() -> Div<V, StatelessInteractivity<V>, FocusDisabled> {
impl<V, F> Div<V, StatelessInteractivity<V>, F>
where
V: 'static,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
pub fn id(self, id: impl Into<ElementId>) -> Div<V, StatefulInteractivity<V>, F> {
Div {
interactivity: StatefulInteractivity::new(id.into(), self.interactivity),
- focus: self.focus,
+ key_dispatch: self.key_dispatch,
children: self.children,
group: self.group,
base_style: self.base_style,
@@ -49,7 +53,7 @@ where
impl<V, I, F> Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
pub fn group(mut self, group: impl Into<SharedString>) -> Self {
self.group = Some(group.into());
@@ -61,6 +65,18 @@ where
self
}
+ pub fn context<C>(mut self, context: C) -> Self
+ where
+ Self: Sized,
+ C: TryInto<KeyContext>,
+ C::Error: Debug,
+ {
+ if let Some(context) = context.try_into().log_err() {
+ *self.key_dispatch.key_context_mut() = context;
+ }
+ self
+ }
+
pub fn overflow_hidden(mut self) -> Self {
self.base_style.overflow.x = Some(Overflow::Hidden);
self.base_style.overflow.y = Some(Overflow::Hidden);
@@ -97,7 +113,7 @@ where
) -> Style {
let mut computed_style = Style::default();
computed_style.refine(&self.base_style);
- self.focus.refine_style(&mut computed_style, cx);
+ self.key_dispatch.refine_style(&mut computed_style, cx);
self.interactivity.refine_style(
&mut computed_style,
bounds,
@@ -108,11 +124,11 @@ where
}
}
-impl<V: 'static> Div<V, StatefulInteractivity<V>, FocusDisabled> {
- pub fn focusable(self) -> Div<V, StatefulInteractivity<V>, FocusEnabled<V>> {
+impl<V: 'static> Div<V, StatefulInteractivity<V>, NonFocusableKeyDispatch> {
+ pub fn focusable(self) -> Div<V, StatefulInteractivity<V>, FocusableKeyDispatch<V>> {
Div {
interactivity: self.interactivity,
- focus: FocusEnabled::new(),
+ key_dispatch: FocusableKeyDispatch::new(),
children: self.children,
group: self.group,
base_style: self.base_style,
@@ -122,10 +138,10 @@ impl<V: 'static> Div<V, StatefulInteractivity<V>, FocusDisabled> {
pub fn track_focus(
self,
handle: &FocusHandle,
- ) -> Div<V, StatefulInteractivity<V>, FocusEnabled<V>> {
+ ) -> Div<V, StatefulInteractivity<V>, FocusableKeyDispatch<V>> {
Div {
interactivity: self.interactivity,
- focus: FocusEnabled::tracked(handle),
+ key_dispatch: FocusableKeyDispatch::tracked(handle),
children: self.children,
group: self.group,
base_style: self.base_style,
@@ -149,14 +165,14 @@ impl<V: 'static> Div<V, StatefulInteractivity<V>, FocusDisabled> {
}
}
-impl<V: 'static> Div<V, StatelessInteractivity<V>, FocusDisabled> {
+impl<V: 'static> Div<V, StatelessInteractivity<V>, NonFocusableKeyDispatch> {
pub fn track_focus(
self,
handle: &FocusHandle,
- ) -> Div<V, StatefulInteractivity<V>, FocusEnabled<V>> {
+ ) -> Div<V, StatefulInteractivity<V>, FocusableKeyDispatch<V>> {
Div {
interactivity: self.interactivity.into_stateful(handle),
- focus: handle.clone().into(),
+ key_dispatch: handle.clone().into(),
children: self.children,
group: self.group,
base_style: self.base_style,
@@ -164,25 +180,25 @@ impl<V: 'static> Div<V, StatelessInteractivity<V>, FocusDisabled> {
}
}
-impl<V, I> Focusable<V> for Div<V, I, FocusEnabled<V>>
+impl<V, I> Focusable<V> for Div<V, I, FocusableKeyDispatch<V>>
where
V: 'static,
I: ElementInteractivity<V>,
{
fn focus_listeners(&mut self) -> &mut FocusListeners<V> {
- &mut self.focus.focus_listeners
+ &mut self.key_dispatch.focus_listeners
}
fn set_focus_style(&mut self, style: StyleRefinement) {
- self.focus.focus_style = style;
+ self.key_dispatch.focus_style = style;
}
fn set_focus_in_style(&mut self, style: StyleRefinement) {
- self.focus.focus_in_style = style;
+ self.key_dispatch.focus_in_style = style;
}
fn set_in_focus_style(&mut self, style: StyleRefinement) {
- self.focus.in_focus_style = style;
+ self.key_dispatch.in_focus_style = style;
}
}
@@ -196,7 +212,7 @@ pub struct DivState {
impl<V, I, F> Element<V> for Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
type ElementState = DivState;
@@ -213,14 +229,17 @@ where
cx: &mut ViewContext<V>,
) -> Self::ElementState {
let mut element_state = element_state.unwrap_or_default();
- self.interactivity.initialize(cx, |cx| {
- self.focus
- .initialize(element_state.focus_handle.take(), cx, |focus_handle, cx| {
+ self.with_element_id(cx, |this, _global_id, cx| {
+ this.key_dispatch.initialize(
+ element_state.focus_handle.take(),
+ cx,
+ |focus_handle, cx| {
element_state.focus_handle = focus_handle;
- for child in &mut self.children {
+ for child in &mut this.children {
child.initialize(view_state, cx);
}
- })
+ },
+ );
});
element_state
}
@@ -288,7 +307,7 @@ where
cx.with_z_index(z_index, |cx| {
cx.with_z_index(0, |cx| {
style.paint(bounds, cx);
- this.focus.paint(bounds, cx);
+ this.key_dispatch.paint(bounds, cx);
this.interactivity.paint(
bounds,
content_size,
@@ -321,7 +340,7 @@ where
impl<V, I, F> Component<V> for Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn render(self) -> AnyElement<V> {
AnyElement::new(self)
@@ -331,7 +350,7 @@ where
impl<V, I, F> ParentElement<V> for Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
&mut self.children
@@ -341,7 +360,7 @@ where
impl<V, I, F> Styled for Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn style(&mut self) -> &mut StyleRefinement {
&mut self.base_style
@@ -351,7 +370,7 @@ where
impl<V, I, F> StatelessInteractive<V> for Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn stateless_interactivity(&mut self) -> &mut StatelessInteractivity<V> {
self.interactivity.as_stateless_mut()
@@ -360,7 +379,7 @@ where
impl<V, F> StatefulInteractive<V> for Div<V, StatefulInteractivity<V>, F>
where
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn stateful_interactivity(&mut self) -> &mut StatefulInteractivity<V> {
&mut self.interactivity
@@ -1,7 +1,7 @@
use crate::{
- div, AnyElement, BorrowWindow, Bounds, Component, Div, DivState, Element, ElementFocus,
- ElementId, ElementInteractivity, FocusDisabled, FocusEnabled, FocusListeners, Focusable,
- LayoutId, Pixels, SharedString, StatefulInteractive, StatefulInteractivity,
+ div, AnyElement, BorrowWindow, Bounds, Component, Div, DivState, Element, ElementId,
+ ElementInteractivity, FocusListeners, Focusable, FocusableKeyDispatch, KeyDispatch, LayoutId,
+ NonFocusableKeyDispatch, Pixels, SharedString, StatefulInteractive, StatefulInteractivity,
StatelessInteractive, StatelessInteractivity, StyleRefinement, Styled, ViewContext,
};
use futures::FutureExt;
@@ -10,14 +10,14 @@ use util::ResultExt;
pub struct Img<
V: 'static,
I: ElementInteractivity<V> = StatelessInteractivity<V>,
- F: ElementFocus<V> = FocusDisabled,
+ F: KeyDispatch<V> = NonFocusableKeyDispatch,
> {
base: Div<V, I, F>,
uri: Option<SharedString>,
grayscale: bool,
}
-pub fn img<V: 'static>() -> Img<V, StatelessInteractivity<V>, FocusDisabled> {
+pub fn img<V: 'static>() -> Img<V, StatelessInteractivity<V>, NonFocusableKeyDispatch> {
Img {
base: div(),
uri: None,
@@ -29,7 +29,7 @@ impl<V, I, F> Img<V, I, F>
where
V: 'static,
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
pub fn uri(mut self, uri: impl Into<SharedString>) -> Self {
self.uri = Some(uri.into());
@@ -44,7 +44,7 @@ where
impl<V, F> Img<V, StatelessInteractivity<V>, F>
where
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
pub fn id(self, id: impl Into<ElementId>) -> Img<V, StatefulInteractivity<V>, F> {
Img {
@@ -58,7 +58,7 @@ where
impl<V, I, F> Component<V> for Img<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn render(self) -> AnyElement<V> {
AnyElement::new(self)
@@ -68,7 +68,7 @@ where
impl<V, I, F> Element<V> for Img<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
type ElementState = DivState;
@@ -137,7 +137,7 @@ where
impl<V, I, F> Styled for Img<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn style(&mut self) -> &mut StyleRefinement {
self.base.style()
@@ -147,7 +147,7 @@ where
impl<V, I, F> StatelessInteractive<V> for Img<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn stateless_interactivity(&mut self) -> &mut StatelessInteractivity<V> {
self.base.stateless_interactivity()
@@ -156,14 +156,14 @@ where
impl<V, F> StatefulInteractive<V> for Img<V, StatefulInteractivity<V>, F>
where
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn stateful_interactivity(&mut self) -> &mut StatefulInteractivity<V> {
self.base.stateful_interactivity()
}
}
-impl<V, I> Focusable<V> for Img<V, I, FocusEnabled<V>>
+impl<V, I> Focusable<V> for Img<V, I, FocusableKeyDispatch<V>>
where
V: 'static,
I: ElementInteractivity<V>,
@@ -1,21 +1,21 @@
use crate::{
- div, AnyElement, Bounds, Component, Div, DivState, Element, ElementFocus, ElementId,
- ElementInteractivity, FocusDisabled, FocusEnabled, FocusListeners, Focusable, LayoutId, Pixels,
- SharedString, StatefulInteractive, StatefulInteractivity, StatelessInteractive,
- StatelessInteractivity, StyleRefinement, Styled, ViewContext,
+ div, AnyElement, Bounds, Component, Div, DivState, Element, ElementId, ElementInteractivity,
+ FocusListeners, Focusable, FocusableKeyDispatch, KeyDispatch, LayoutId,
+ NonFocusableKeyDispatch, Pixels, SharedString, StatefulInteractive, StatefulInteractivity,
+ StatelessInteractive, StatelessInteractivity, StyleRefinement, Styled, ViewContext,
};
use util::ResultExt;
pub struct Svg<
V: 'static,
I: ElementInteractivity<V> = StatelessInteractivity<V>,
- F: ElementFocus<V> = FocusDisabled,
+ F: KeyDispatch<V> = NonFocusableKeyDispatch,
> {
base: Div<V, I, F>,
path: Option<SharedString>,
}
-pub fn svg<V: 'static>() -> Svg<V, StatelessInteractivity<V>, FocusDisabled> {
+pub fn svg<V: 'static>() -> Svg<V, StatelessInteractivity<V>, NonFocusableKeyDispatch> {
Svg {
base: div(),
path: None,
@@ -25,7 +25,7 @@ pub fn svg<V: 'static>() -> Svg<V, StatelessInteractivity<V>, FocusDisabled> {
impl<V, I, F> Svg<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
pub fn path(mut self, path: impl Into<SharedString>) -> Self {
self.path = Some(path.into());
@@ -35,7 +35,7 @@ where
impl<V, F> Svg<V, StatelessInteractivity<V>, F>
where
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
pub fn id(self, id: impl Into<ElementId>) -> Svg<V, StatefulInteractivity<V>, F> {
Svg {
@@ -48,7 +48,7 @@ where
impl<V, I, F> Component<V> for Svg<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn render(self) -> AnyElement<V> {
AnyElement::new(self)
@@ -58,7 +58,7 @@ where
impl<V, I, F> Element<V> for Svg<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
type ElementState = DivState;
@@ -108,7 +108,7 @@ where
impl<V, I, F> Styled for Svg<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn style(&mut self) -> &mut StyleRefinement {
self.base.style()
@@ -118,7 +118,7 @@ where
impl<V, I, F> StatelessInteractive<V> for Svg<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn stateless_interactivity(&mut self) -> &mut StatelessInteractivity<V> {
self.base.stateless_interactivity()
@@ -128,14 +128,14 @@ where
impl<V, F> StatefulInteractive<V> for Svg<V, StatefulInteractivity<V>, F>
where
V: 'static,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
fn stateful_interactivity(&mut self) -> &mut StatefulInteractivity<V> {
self.base.stateful_interactivity()
}
}
-impl<V: 'static, I> Focusable<V> for Svg<V, I, FocusEnabled<V>>
+impl<V: 'static, I> Focusable<V> for Svg<V, I, FocusableKeyDispatch<V>>
where
I: ElementInteractivity<V>,
{
@@ -1,252 +0,0 @@
-use crate::{
- Bounds, DispatchPhase, Element, FocusEvent, FocusHandle, MouseDownEvent, Pixels, Style,
- StyleRefinement, ViewContext, WindowContext,
-};
-use refineable::Refineable;
-use smallvec::SmallVec;
-
-pub type FocusListeners<V> = SmallVec<[FocusListener<V>; 2]>;
-
-pub type FocusListener<V> =
- Box<dyn Fn(&mut V, &FocusHandle, &FocusEvent, &mut ViewContext<V>) + 'static>;
-
-pub trait Focusable<V: 'static>: Element<V> {
- fn focus_listeners(&mut self) -> &mut FocusListeners<V>;
- fn set_focus_style(&mut self, style: StyleRefinement);
- fn set_focus_in_style(&mut self, style: StyleRefinement);
- fn set_in_focus_style(&mut self, style: StyleRefinement);
-
- fn focus(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
- where
- Self: Sized,
- {
- self.set_focus_style(f(StyleRefinement::default()));
- self
- }
-
- fn focus_in(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
- where
- Self: Sized,
- {
- self.set_focus_in_style(f(StyleRefinement::default()));
- self
- }
-
- fn in_focus(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
- where
- Self: Sized,
- {
- self.set_in_focus_style(f(StyleRefinement::default()));
- self
- }
-
- fn on_focus(
- mut self,
- listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.focus_listeners()
- .push(Box::new(move |view, focus_handle, event, cx| {
- if event.focused.as_ref() == Some(focus_handle) {
- listener(view, event, cx)
- }
- }));
- self
- }
-
- fn on_blur(
- mut self,
- listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.focus_listeners()
- .push(Box::new(move |view, focus_handle, event, cx| {
- if event.blurred.as_ref() == Some(focus_handle) {
- listener(view, event, cx)
- }
- }));
- self
- }
-
- fn on_focus_in(
- mut self,
- listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.focus_listeners()
- .push(Box::new(move |view, focus_handle, event, cx| {
- let descendant_blurred = event
- .blurred
- .as_ref()
- .map_or(false, |blurred| focus_handle.contains(blurred, cx));
- let descendant_focused = event
- .focused
- .as_ref()
- .map_or(false, |focused| focus_handle.contains(focused, cx));
-
- if !descendant_blurred && descendant_focused {
- listener(view, event, cx)
- }
- }));
- self
- }
-
- fn on_focus_out(
- mut self,
- listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
- ) -> Self
- where
- Self: Sized,
- {
- self.focus_listeners()
- .push(Box::new(move |view, focus_handle, event, cx| {
- let descendant_blurred = event
- .blurred
- .as_ref()
- .map_or(false, |blurred| focus_handle.contains(blurred, cx));
- let descendant_focused = event
- .focused
- .as_ref()
- .map_or(false, |focused| focus_handle.contains(focused, cx));
- if descendant_blurred && !descendant_focused {
- listener(view, event, cx)
- }
- }));
- self
- }
-}
-
-pub trait ElementFocus<V: 'static>: 'static {
- fn as_focusable(&self) -> Option<&FocusEnabled<V>>;
- fn as_focusable_mut(&mut self) -> Option<&mut FocusEnabled<V>>;
-
- fn initialize<R>(
- &mut self,
- focus_handle: Option<FocusHandle>,
- cx: &mut ViewContext<V>,
- f: impl FnOnce(Option<FocusHandle>, &mut ViewContext<V>) -> R,
- ) -> R {
- if let Some(focusable) = self.as_focusable_mut() {
- let focus_handle = focusable
- .focus_handle
- .get_or_insert_with(|| focus_handle.unwrap_or_else(|| cx.focus_handle()))
- .clone();
- for listener in focusable.focus_listeners.drain(..) {
- let focus_handle = focus_handle.clone();
- cx.on_focus_changed(move |view, event, cx| {
- listener(view, &focus_handle, event, cx)
- });
- }
- cx.with_focus(focus_handle.clone(), |cx| f(Some(focus_handle), cx))
- } else {
- f(None, cx)
- }
- }
-
- fn refine_style(&self, style: &mut Style, cx: &WindowContext) {
- if let Some(focusable) = self.as_focusable() {
- let focus_handle = focusable
- .focus_handle
- .as_ref()
- .expect("must call initialize before refine_style");
- if focus_handle.contains_focused(cx) {
- style.refine(&focusable.focus_in_style);
- }
-
- if focus_handle.within_focused(cx) {
- style.refine(&focusable.in_focus_style);
- }
-
- if focus_handle.is_focused(cx) {
- style.refine(&focusable.focus_style);
- }
- }
- }
-
- fn paint(&self, bounds: Bounds<Pixels>, cx: &mut WindowContext) {
- if let Some(focusable) = self.as_focusable() {
- let focus_handle = focusable
- .focus_handle
- .clone()
- .expect("must call initialize before paint");
- cx.on_mouse_event(move |event: &MouseDownEvent, phase, cx| {
- if phase == DispatchPhase::Bubble && bounds.contains_point(&event.position) {
- if !cx.default_prevented() {
- cx.focus(&focus_handle);
- cx.prevent_default();
- }
- }
- })
- }
- }
-}
-
-pub struct FocusEnabled<V> {
- pub focus_handle: Option<FocusHandle>,
- pub focus_listeners: FocusListeners<V>,
- pub focus_style: StyleRefinement,
- pub focus_in_style: StyleRefinement,
- pub in_focus_style: StyleRefinement,
-}
-
-impl<V> FocusEnabled<V> {
- pub fn new() -> Self {
- Self {
- focus_handle: None,
- focus_listeners: FocusListeners::default(),
- focus_style: StyleRefinement::default(),
- focus_in_style: StyleRefinement::default(),
- in_focus_style: StyleRefinement::default(),
- }
- }
-
- pub fn tracked(handle: &FocusHandle) -> Self {
- Self {
- focus_handle: Some(handle.clone()),
- focus_listeners: FocusListeners::default(),
- focus_style: StyleRefinement::default(),
- focus_in_style: StyleRefinement::default(),
- in_focus_style: StyleRefinement::default(),
- }
- }
-}
-
-impl<V: 'static> ElementFocus<V> for FocusEnabled<V> {
- fn as_focusable(&self) -> Option<&FocusEnabled<V>> {
- Some(self)
- }
-
- fn as_focusable_mut(&mut self) -> Option<&mut FocusEnabled<V>> {
- Some(self)
- }
-}
-
-impl<V> From<FocusHandle> for FocusEnabled<V> {
- fn from(value: FocusHandle) -> Self {
- Self {
- focus_handle: Some(value),
- focus_listeners: FocusListeners::default(),
- focus_style: StyleRefinement::default(),
- focus_in_style: StyleRefinement::default(),
- in_focus_style: StyleRefinement::default(),
- }
- }
-}
-
-pub struct FocusDisabled;
-
-impl<V: 'static> ElementFocus<V> for FocusDisabled {
- fn as_focusable(&self) -> Option<&FocusEnabled<V>> {
- None
- }
-
- fn as_focusable_mut(&mut self) -> Option<&mut FocusEnabled<V>> {
- None
- }
-}
@@ -3,17 +3,17 @@ mod action;
mod app;
mod assets;
mod color;
-mod dispatch;
mod element;
mod elements;
mod executor;
-mod focusable;
mod geometry;
mod image_cache;
mod input;
mod interactive;
+mod key_dispatch;
mod keymap;
mod platform;
+pub mod prelude;
mod scene;
mod style;
mod styled;
@@ -42,12 +42,12 @@ pub use ctor::ctor;
pub use element::*;
pub use elements::*;
pub use executor::*;
-pub use focusable::*;
pub use geometry::*;
pub use gpui2_macros::*;
pub use image_cache::*;
pub use input::*;
pub use interactive::*;
+pub use key_dispatch::*;
pub use keymap::*;
pub use platform::*;
use private::Sealed;
@@ -1,8 +1,8 @@
use crate::{
- div, point, px, Action, AnyDrag, AnyTooltip, AnyView, AppContext, BorrowWindow, Bounds,
- Component, DispatchPhase, Div, Element, ElementId, FocusHandle, KeyBindingContext, KeyMatch,
- Keystroke, Modifiers, Overflow, Pixels, Point, Render, SharedString, Size, Style,
- StyleRefinement, Task, View, ViewContext,
+ div, point, px, Action, AnyDrag, AnyTooltip, AnyView, AppContext, Bounds, Component,
+ DispatchPhase, Div, Element, ElementId, FocusHandle, KeyContext, Keystroke, Modifiers,
+ Overflow, Pixels, Point, Render, SharedString, Size, Style, StyleRefinement, Task, View,
+ ViewContext,
};
use collections::HashMap;
use derive_more::{Deref, DerefMut};
@@ -164,17 +164,6 @@ pub trait StatelessInteractive<V: 'static>: Element<V> {
self
}
- fn context<C>(mut self, context: C) -> Self
- where
- Self: Sized,
- C: TryInto<KeyBindingContext>,
- C::Error: Debug,
- {
- self.stateless_interactivity().dispatch_context =
- context.try_into().expect("invalid dispatch context");
- self
- }
-
/// Capture the given action, fires during the capture phase
fn capture_action<A: 'static>(
mut self,
@@ -396,25 +385,6 @@ pub trait ElementInteractivity<V: 'static>: 'static {
fn as_stateful(&self) -> Option<&StatefulInteractivity<V>>;
fn as_stateful_mut(&mut self) -> Option<&mut StatefulInteractivity<V>>;
- fn initialize<R>(
- &mut self,
- cx: &mut ViewContext<V>,
- f: impl FnOnce(&mut ViewContext<V>) -> R,
- ) -> R {
- if let Some(stateful) = self.as_stateful_mut() {
- cx.with_element_id(stateful.id.clone(), |global_id, cx| {
- cx.with_key_dispatch_context(stateful.dispatch_context.clone(), |cx| {
- cx.with_key_listeners(mem::take(&mut stateful.key_listeners), f)
- })
- })
- } else {
- let stateless = self.as_stateless_mut();
- cx.with_key_dispatch_context(stateless.dispatch_context.clone(), |cx| {
- cx.with_key_listeners(mem::take(&mut stateless.key_listeners), f)
- })
- }
- }
-
fn refine_style(
&self,
style: &mut Style,
@@ -790,7 +760,7 @@ impl<V: 'static> ElementInteractivity<V> for StatefulInteractivity<V> {
type DropListener<V> = dyn Fn(&mut V, AnyView, &mut ViewContext<V>) + 'static;
pub struct StatelessInteractivity<V> {
- pub dispatch_context: KeyBindingContext,
+ pub dispatch_context: KeyContext,
pub mouse_down_listeners: SmallVec<[MouseDownListener<V>; 2]>,
pub mouse_up_listeners: SmallVec<[MouseUpListener<V>; 2]>,
pub mouse_move_listeners: SmallVec<[MouseMoveListener<V>; 2]>,
@@ -892,7 +862,7 @@ impl InteractiveElementState {
impl<V> Default for StatelessInteractivity<V> {
fn default() -> Self {
Self {
- dispatch_context: KeyBindingContext::default(),
+ dispatch_context: KeyContext::default(),
mouse_down_listeners: SmallVec::new(),
mouse_up_listeners: SmallVec::new(),
mouse_move_listeners: SmallVec::new(),
@@ -1236,7 +1206,7 @@ pub type KeyListener<V> = Box<
dyn Fn(
&mut V,
&dyn Any,
- &[&KeyBindingContext],
+ &[&KeyContext],
DispatchPhase,
&mut ViewContext<V>,
) -> Option<Box<dyn Action>>
@@ -0,0 +1,547 @@
+use crate::{
+ build_action_from_type, Action, Bounds, DispatchPhase, Element, FocusEvent, FocusHandle,
+ FocusId, KeyContext, KeyDownEvent, KeyMatch, Keymap, KeystrokeMatcher, MouseDownEvent, Pixels,
+ Style, StyleRefinement, ViewContext, WindowContext,
+};
+use collections::HashMap;
+use parking_lot::Mutex;
+use refineable::Refineable;
+use smallvec::SmallVec;
+use std::{
+ any::{Any, TypeId},
+ sync::Arc,
+};
+use util::ResultExt;
+
+type KeyListener = Box<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>;
+pub type FocusListeners<V> = SmallVec<[FocusListener<V>; 2]>;
+pub type FocusListener<V> =
+ Box<dyn Fn(&mut V, &FocusHandle, &FocusEvent, &mut ViewContext<V>) + 'static>;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub struct DispatchNodeId(usize);
+
+pub struct KeyDispatcher {
+ node_stack: Vec<DispatchNodeId>,
+ context_stack: Vec<KeyContext>,
+ nodes: Vec<DispatchNode>,
+ focusable_node_ids: HashMap<FocusId, DispatchNodeId>,
+ keystroke_matchers: HashMap<SmallVec<[KeyContext; 4]>, KeystrokeMatcher>,
+ keymap: Arc<Mutex<Keymap>>,
+}
+
+#[derive(Default)]
+pub struct DispatchNode {
+ key_listeners: SmallVec<[KeyListener; 2]>,
+ action_listeners: SmallVec<[ActionListener; 16]>,
+ context: KeyContext,
+ parent: Option<DispatchNodeId>,
+}
+
+struct ActionListener {
+ action_type: TypeId,
+ listener: Box<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>,
+}
+
+impl KeyDispatcher {
+ pub fn new(keymap: Arc<Mutex<Keymap>>) -> Self {
+ Self {
+ node_stack: Vec::new(),
+ context_stack: Vec::new(),
+ nodes: Vec::new(),
+ focusable_node_ids: HashMap::default(),
+ keystroke_matchers: HashMap::default(),
+ keymap,
+ }
+ }
+
+ pub fn clear(&mut self) {
+ self.node_stack.clear();
+ self.nodes.clear();
+ }
+
+ pub fn push_node(&mut self, context: KeyContext, old_dispatcher: &mut Self) {
+ let parent = self.node_stack.last().copied();
+ let node_id = DispatchNodeId(self.nodes.len());
+ self.nodes.push(DispatchNode {
+ parent,
+ ..Default::default()
+ });
+ self.node_stack.push(node_id);
+ if !context.is_empty() {
+ self.context_stack.push(context);
+ if let Some((context_stack, matcher)) = old_dispatcher
+ .keystroke_matchers
+ .remove_entry(self.context_stack.as_slice())
+ {
+ self.keystroke_matchers.insert(context_stack, matcher);
+ }
+ }
+ }
+
+ pub fn pop_node(&mut self) {
+ let node_id = self.node_stack.pop().unwrap();
+ if !self.nodes[node_id.0].context.is_empty() {
+ self.context_stack.pop();
+ }
+ }
+
+ pub fn on_key_event(&mut self, listener: KeyListener) {
+ self.active_node().key_listeners.push(listener);
+ }
+
+ pub fn on_action(
+ &mut self,
+ action_type: TypeId,
+ listener: Box<dyn Fn(&dyn Any, DispatchPhase, &mut WindowContext)>,
+ ) {
+ self.active_node().action_listeners.push(ActionListener {
+ action_type,
+ listener,
+ });
+ }
+
+ pub fn make_focusable(&mut self, focus_id: FocusId) {
+ self.focusable_node_ids
+ .insert(focus_id, self.active_node_id());
+ }
+
+ pub fn focus_contains(&self, parent: FocusId, child: FocusId) -> bool {
+ if parent == child {
+ return true;
+ }
+
+ if let Some(parent_node_id) = self.focusable_node_ids.get(&parent) {
+ let mut current_node_id = self.focusable_node_ids.get(&child).copied();
+ while let Some(node_id) = current_node_id {
+ if node_id == *parent_node_id {
+ return true;
+ }
+ current_node_id = self.nodes[node_id.0].parent;
+ }
+ }
+ false
+ }
+
+ pub fn available_actions(&self, target: FocusId) -> Vec<Box<dyn Action>> {
+ let mut actions = Vec::new();
+ if let Some(node) = self.focusable_node_ids.get(&target) {
+ for node_id in self.dispatch_path(*node) {
+ let node = &self.nodes[node_id.0];
+ for ActionListener { action_type, .. } in &node.action_listeners {
+ actions.extend(build_action_from_type(action_type).log_err());
+ }
+ }
+ }
+ actions
+ }
+
+ pub fn dispatch_key(&mut self, target: FocusId, event: &dyn Any, cx: &mut WindowContext) {
+ if let Some(target_node_id) = self.focusable_node_ids.get(&target).copied() {
+ self.dispatch_key_on_node(target_node_id, event, cx);
+ }
+ }
+
+ fn dispatch_key_on_node(
+ &mut self,
+ node_id: DispatchNodeId,
+ event: &dyn Any,
+ cx: &mut WindowContext,
+ ) {
+ let dispatch_path = self.dispatch_path(node_id);
+
+ // Capture phase
+ self.context_stack.clear();
+ cx.propagate_event = true;
+ for node_id in &dispatch_path {
+ let node = &self.nodes[node_id.0];
+ if !node.context.is_empty() {
+ self.context_stack.push(node.context.clone());
+ }
+
+ for key_listener in &node.key_listeners {
+ key_listener(event, DispatchPhase::Capture, cx);
+ if !cx.propagate_event {
+ return;
+ }
+ }
+ }
+
+ // Bubble phase
+ for node_id in dispatch_path.iter().rev() {
+ let node = &self.nodes[node_id.0];
+
+ // Handle low level key events
+ for key_listener in &node.key_listeners {
+ key_listener(event, DispatchPhase::Bubble, cx);
+ if !cx.propagate_event {
+ return;
+ }
+ }
+
+ // Match keystrokes
+ if !node.context.is_empty() {
+ if let Some(key_down_event) = event.downcast_ref::<KeyDownEvent>() {
+ if !self
+ .keystroke_matchers
+ .contains_key(self.context_stack.as_slice())
+ {
+ let keystroke_contexts = self.context_stack.iter().cloned().collect();
+ self.keystroke_matchers.insert(
+ keystroke_contexts,
+ KeystrokeMatcher::new(self.keymap.clone()),
+ );
+ }
+
+ if let Some(keystroke_matcher) = self
+ .keystroke_matchers
+ .get_mut(self.context_stack.as_slice())
+ {
+ if let KeyMatch::Some(action) = keystroke_matcher.match_keystroke(
+ &key_down_event.keystroke,
+ self.context_stack.as_slice(),
+ ) {
+ self.dispatch_action_on_node(*node_id, action, cx);
+ if !cx.propagate_event {
+ return;
+ }
+ }
+ }
+ }
+
+ self.context_stack.pop();
+ }
+ }
+ }
+
+ pub fn dispatch_action(
+ &self,
+ target: FocusId,
+ action: Box<dyn Action>,
+ cx: &mut WindowContext,
+ ) {
+ if let Some(target_node_id) = self.focusable_node_ids.get(&target).copied() {
+ self.dispatch_action_on_node(target_node_id, action, cx);
+ }
+ }
+
+ fn dispatch_action_on_node(
+ &self,
+ node_id: DispatchNodeId,
+ action: Box<dyn Action>,
+ cx: &mut WindowContext,
+ ) {
+ let dispatch_path = self.dispatch_path(node_id);
+
+ // Capture phase
+ for node_id in &dispatch_path {
+ let node = &self.nodes[node_id.0];
+ for ActionListener { listener, .. } in &node.action_listeners {
+ listener(&action, DispatchPhase::Capture, cx);
+ if !cx.propagate_event {
+ return;
+ }
+ }
+ }
+
+ // Bubble phase
+ for node_id in dispatch_path.iter().rev() {
+ let node = &self.nodes[node_id.0];
+ for ActionListener { listener, .. } in &node.action_listeners {
+ cx.propagate_event = false; // Actions stop propagation by default during the bubble phase
+ listener(&action, DispatchPhase::Capture, cx);
+ if !cx.propagate_event {
+ return;
+ }
+ }
+ }
+ }
+
+ fn active_node(&mut self) -> &mut DispatchNode {
+ let active_node_id = self.active_node_id();
+ &mut self.nodes[active_node_id.0]
+ }
+
+ fn active_node_id(&self) -> DispatchNodeId {
+ *self.node_stack.last().unwrap()
+ }
+
+ /// Returns the DispatchNodeIds from the root of the tree to the given target node id.
+ fn dispatch_path(&self, target: DispatchNodeId) -> SmallVec<[DispatchNodeId; 32]> {
+ let mut dispatch_path: SmallVec<[DispatchNodeId; 32]> = SmallVec::new();
+ let mut current_node_id = Some(target);
+ while let Some(node_id) = current_node_id {
+ dispatch_path.push(node_id);
+ current_node_id = self.nodes[node_id.0].parent;
+ }
+ dispatch_path.reverse(); // Reverse the path so it goes from the root to the focused node.
+ dispatch_path
+ }
+}
+
+pub trait KeyDispatch<V: 'static>: 'static {
+ fn as_focusable(&self) -> Option<&FocusableKeyDispatch<V>>;
+ fn as_focusable_mut(&mut self) -> Option<&mut FocusableKeyDispatch<V>>;
+ fn key_context(&self) -> &KeyContext;
+ fn key_context_mut(&mut self) -> &mut KeyContext;
+
+ fn initialize<R>(
+ &mut self,
+ focus_handle: Option<FocusHandle>,
+ cx: &mut ViewContext<V>,
+ f: impl FnOnce(Option<FocusHandle>, &mut ViewContext<V>) -> R,
+ ) -> R {
+ if let Some(focusable) = self.as_focusable_mut() {
+ let focus_handle = focusable
+ .focus_handle
+ .get_or_insert_with(|| focus_handle.unwrap_or_else(|| cx.focus_handle()))
+ .clone();
+ for listener in focusable.focus_listeners.drain(..) {
+ let focus_handle = focus_handle.clone();
+ cx.on_focus_changed(move |view, event, cx| {
+ listener(view, &focus_handle, event, cx)
+ });
+ }
+
+ cx.with_key_dispatch(self.key_context().clone(), Some(focus_handle), f)
+ } else {
+ f(None, cx)
+ }
+ }
+
+ fn refine_style(&self, style: &mut Style, cx: &WindowContext) {
+ if let Some(focusable) = self.as_focusable() {
+ let focus_handle = focusable
+ .focus_handle
+ .as_ref()
+ .expect("must call initialize before refine_style");
+ if focus_handle.contains_focused(cx) {
+ style.refine(&focusable.focus_in_style);
+ }
+
+ if focus_handle.within_focused(cx) {
+ style.refine(&focusable.in_focus_style);
+ }
+
+ if focus_handle.is_focused(cx) {
+ style.refine(&focusable.focus_style);
+ }
+ }
+ }
+
+ fn paint(&self, bounds: Bounds<Pixels>, cx: &mut WindowContext) {
+ if let Some(focusable) = self.as_focusable() {
+ let focus_handle = focusable
+ .focus_handle
+ .clone()
+ .expect("must call initialize before paint");
+ cx.on_mouse_event(move |event: &MouseDownEvent, phase, cx| {
+ if phase == DispatchPhase::Bubble && bounds.contains_point(&event.position) {
+ if !cx.default_prevented() {
+ cx.focus(&focus_handle);
+ cx.prevent_default();
+ }
+ }
+ })
+ }
+ }
+}
+
+pub struct FocusableKeyDispatch<V> {
+ pub key_context: KeyContext,
+ pub focus_handle: Option<FocusHandle>,
+ pub focus_listeners: FocusListeners<V>,
+ pub focus_style: StyleRefinement,
+ pub focus_in_style: StyleRefinement,
+ pub in_focus_style: StyleRefinement,
+}
+
+impl<V> FocusableKeyDispatch<V> {
+ pub fn new() -> Self {
+ Self {
+ key_context: KeyContext::default(),
+ focus_handle: None,
+ focus_listeners: FocusListeners::default(),
+ focus_style: StyleRefinement::default(),
+ focus_in_style: StyleRefinement::default(),
+ in_focus_style: StyleRefinement::default(),
+ }
+ }
+
+ pub fn tracked(handle: &FocusHandle) -> Self {
+ Self {
+ key_context: KeyContext::default(),
+ focus_handle: Some(handle.clone()),
+ focus_listeners: FocusListeners::default(),
+ focus_style: StyleRefinement::default(),
+ focus_in_style: StyleRefinement::default(),
+ in_focus_style: StyleRefinement::default(),
+ }
+ }
+}
+
+impl<V: 'static> KeyDispatch<V> for FocusableKeyDispatch<V> {
+ fn as_focusable(&self) -> Option<&FocusableKeyDispatch<V>> {
+ Some(self)
+ }
+
+ fn as_focusable_mut(&mut self) -> Option<&mut FocusableKeyDispatch<V>> {
+ Some(self)
+ }
+
+ fn key_context(&self) -> &KeyContext {
+ &self.key_context
+ }
+
+ fn key_context_mut(&mut self) -> &mut KeyContext {
+ &mut self.key_context
+ }
+}
+
+impl<V> From<FocusHandle> for FocusableKeyDispatch<V> {
+ fn from(value: FocusHandle) -> Self {
+ Self {
+ key_context: KeyContext::default(),
+ focus_handle: Some(value),
+ focus_listeners: FocusListeners::default(),
+ focus_style: StyleRefinement::default(),
+ focus_in_style: StyleRefinement::default(),
+ in_focus_style: StyleRefinement::default(),
+ }
+ }
+}
+
+#[derive(Default)]
+pub struct NonFocusableKeyDispatch {
+ pub(crate) key_context: KeyContext,
+}
+
+impl<V: 'static> KeyDispatch<V> for NonFocusableKeyDispatch {
+ fn as_focusable(&self) -> Option<&FocusableKeyDispatch<V>> {
+ None
+ }
+
+ fn as_focusable_mut(&mut self) -> Option<&mut FocusableKeyDispatch<V>> {
+ None
+ }
+
+ fn key_context(&self) -> &KeyContext {
+ &self.key_context
+ }
+
+ fn key_context_mut(&mut self) -> &mut KeyContext {
+ &mut self.key_context
+ }
+}
+
+pub trait Focusable<V: 'static>: Element<V> {
+ fn focus_listeners(&mut self) -> &mut FocusListeners<V>;
+ fn set_focus_style(&mut self, style: StyleRefinement);
+ fn set_focus_in_style(&mut self, style: StyleRefinement);
+ fn set_in_focus_style(&mut self, style: StyleRefinement);
+
+ fn focus(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
+ where
+ Self: Sized,
+ {
+ self.set_focus_style(f(StyleRefinement::default()));
+ self
+ }
+
+ fn focus_in(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
+ where
+ Self: Sized,
+ {
+ self.set_focus_in_style(f(StyleRefinement::default()));
+ self
+ }
+
+ fn in_focus(mut self, f: impl FnOnce(StyleRefinement) -> StyleRefinement) -> Self
+ where
+ Self: Sized,
+ {
+ self.set_in_focus_style(f(StyleRefinement::default()));
+ self
+ }
+
+ fn on_focus(
+ mut self,
+ listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
+ ) -> Self
+ where
+ Self: Sized,
+ {
+ self.focus_listeners()
+ .push(Box::new(move |view, focus_handle, event, cx| {
+ if event.focused.as_ref() == Some(focus_handle) {
+ listener(view, event, cx)
+ }
+ }));
+ self
+ }
+
+ fn on_blur(
+ mut self,
+ listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
+ ) -> Self
+ where
+ Self: Sized,
+ {
+ self.focus_listeners()
+ .push(Box::new(move |view, focus_handle, event, cx| {
+ if event.blurred.as_ref() == Some(focus_handle) {
+ listener(view, event, cx)
+ }
+ }));
+ self
+ }
+
+ fn on_focus_in(
+ mut self,
+ listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
+ ) -> Self
+ where
+ Self: Sized,
+ {
+ self.focus_listeners()
+ .push(Box::new(move |view, focus_handle, event, cx| {
+ let descendant_blurred = event
+ .blurred
+ .as_ref()
+ .map_or(false, |blurred| focus_handle.contains(blurred, cx));
+ let descendant_focused = event
+ .focused
+ .as_ref()
+ .map_or(false, |focused| focus_handle.contains(focused, cx));
+
+ if !descendant_blurred && descendant_focused {
+ listener(view, event, cx)
+ }
+ }));
+ self
+ }
+
+ fn on_focus_out(
+ mut self,
+ listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
+ ) -> Self
+ where
+ Self: Sized,
+ {
+ self.focus_listeners()
+ .push(Box::new(move |view, focus_handle, event, cx| {
+ let descendant_blurred = event
+ .blurred
+ .as_ref()
+ .map_or(false, |blurred| focus_handle.contains(blurred, cx));
+ let descendant_focused = event
+ .focused
+ .as_ref()
+ .map_or(false, |focused| focus_handle.contains(focused, cx));
+ if descendant_blurred && !descendant_focused {
+ listener(view, event, cx)
+ }
+ }));
+ self
+ }
+}
@@ -1,4 +1,4 @@
-use crate::{Action, KeyBindingContext, KeyBindingContextPredicate, KeyMatch, Keystroke};
+use crate::{Action, KeyBindingContextPredicate, KeyContext, KeyMatch, Keystroke};
use anyhow::Result;
use smallvec::SmallVec;
@@ -32,7 +32,7 @@ impl KeyBinding {
})
}
- pub fn matches_context(&self, contexts: &[KeyBindingContext]) -> bool {
+ pub fn matches_context(&self, contexts: &[KeyContext]) -> bool {
self.context_predicate
.as_ref()
.map(|predicate| predicate.eval(contexts))
@@ -42,7 +42,7 @@ impl KeyBinding {
pub fn match_keystrokes(
&self,
pending_keystrokes: &[Keystroke],
- contexts: &[KeyBindingContext],
+ contexts: &[KeyContext],
) -> KeyMatch {
if self.keystrokes.as_ref().starts_with(&pending_keystrokes)
&& self.matches_context(contexts)
@@ -61,7 +61,7 @@ impl KeyBinding {
pub fn keystrokes_for_action(
&self,
action: &dyn Action,
- contexts: &[KeyBindingContext],
+ contexts: &[KeyContext],
) -> Option<SmallVec<[Keystroke; 2]>> {
if self.action.partial_eq(action) && self.matches_context(contexts) {
Some(self.keystrokes.clone())
@@ -3,7 +3,7 @@ use anyhow::{anyhow, Result};
use smallvec::SmallVec;
#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
-pub struct KeyBindingContext(SmallVec<[ContextEntry; 8]>);
+pub struct KeyContext(SmallVec<[ContextEntry; 8]>);
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
struct ContextEntry {
@@ -11,7 +11,7 @@ struct ContextEntry {
value: Option<SharedString>,
}
-impl<'a> TryFrom<&'a str> for KeyBindingContext {
+impl<'a> TryFrom<&'a str> for KeyContext {
type Error = anyhow::Error;
fn try_from(value: &'a str) -> Result<Self> {
@@ -19,7 +19,7 @@ impl<'a> TryFrom<&'a str> for KeyBindingContext {
}
}
-impl KeyBindingContext {
+impl KeyContext {
pub fn parse(source: &str) -> Result<Self> {
let mut context = Self::default();
let source = skip_whitespace(source);
@@ -130,7 +130,7 @@ impl KeyBindingContextPredicate {
}
}
- pub fn eval(&self, contexts: &[KeyBindingContext]) -> bool {
+ pub fn eval(&self, contexts: &[KeyContext]) -> bool {
let Some(context) = contexts.last() else {
return false;
};
@@ -293,19 +293,16 @@ mod tests {
#[test]
fn test_parse_context() {
- let mut expected = KeyBindingContext::default();
+ let mut expected = KeyContext::default();
expected.set("foo", "bar");
expected.add("baz");
- assert_eq!(KeyBindingContext::parse("baz foo=bar").unwrap(), expected);
- assert_eq!(KeyBindingContext::parse("foo = bar baz").unwrap(), expected);
+ assert_eq!(KeyContext::parse("baz foo=bar").unwrap(), expected);
+ assert_eq!(KeyContext::parse("foo = bar baz").unwrap(), expected);
assert_eq!(
- KeyBindingContext::parse(" baz foo = bar baz").unwrap(),
- expected
- );
- assert_eq!(
- KeyBindingContext::parse(" foo = bar baz").unwrap(),
+ KeyContext::parse(" baz foo = bar baz").unwrap(),
expected
);
+ assert_eq!(KeyContext::parse(" foo = bar baz").unwrap(), expected);
}
#[test]
@@ -1,4 +1,4 @@
-use crate::{Action, KeyBindingContext, Keymap, KeymapVersion, Keystroke};
+use crate::{Action, KeyContext, Keymap, KeymapVersion, Keystroke};
use parking_lot::Mutex;
use smallvec::SmallVec;
use std::sync::Arc;
@@ -44,7 +44,7 @@ impl KeystrokeMatcher {
pub fn match_keystroke(
&mut self,
keystroke: &Keystroke,
- context_stack: &[KeyBindingContext],
+ context_stack: &[KeyContext],
) -> KeyMatch {
let keymap = self.keymap.lock();
// Clear pending keystrokes if the keymap has changed since the last matched keystroke.
@@ -86,7 +86,7 @@ impl KeystrokeMatcher {
pub fn keystrokes_for_action(
&self,
action: &dyn Action,
- contexts: &[KeyBindingContext],
+ contexts: &[KeyContext],
) -> Option<SmallVec<[Keystroke; 2]>> {
self.keymap
.lock()
@@ -0,0 +1 @@
+pub use crate::{Context, ParentElement, Refineable};
@@ -184,10 +184,6 @@ impl AnyView {
.compute_layout(layout_id, available_space);
(self.paint)(self, &mut rendered_element, cx);
}
-
- pub(crate) fn draw_dispatch_stack(&self, cx: &mut WindowContext) {
- (self.initialize)(self, cx);
- }
}
impl<V: 'static> Component<V> for AnyView {
@@ -1,15 +1,14 @@
use crate::{
- build_action_from_type, px, size, Action, AnyBox, AnyDrag, AnyView, AppContext,
- AsyncWindowContext, AvailableSpace, Bounds, BoxShadow, Context, Corners, CursorStyle,
- DevicePixels, DisplayId, Edges, Effect, Entity, EntityId, EventEmitter, FileDropEvent,
- FocusEvent, FontId, GlobalElementId, GlyphId, Hsla, ImageData, InputEvent, IsZero,
- KeyBindingContext, KeyListener, KeyMatch, Keystroke, KeystrokeMatcher, LayoutId, Model,
- ModelContext, Modifiers, MonochromeSprite, MouseButton, MouseDownEvent, MouseMoveEvent,
- MouseUpEvent, Path, Pixels, PlatformAtlas, PlatformDisplay, PlatformInputHandler,
- PlatformWindow, Point, PolychromeSprite, PromptLevel, Quad, Render, RenderGlyphParams,
- RenderImageParams, RenderSvgParams, ScaledPixels, SceneBuilder, Shadow, SharedString, Size,
- Style, SubscriberSet, Subscription, TaffyLayoutEngine, Task, Underline, UnderlineStyle, View,
- VisualContext, WeakView, WindowBounds, WindowOptions, SUBPIXEL_VARIANTS,
+ px, size, Action, AnyBox, AnyDrag, AnyView, AppContext, AsyncWindowContext, AvailableSpace,
+ Bounds, BoxShadow, Context, Corners, CursorStyle, DevicePixels, DisplayId, Edges, Effect,
+ Entity, EntityId, EventEmitter, FileDropEvent, FocusEvent, FontId, GlobalElementId, GlyphId,
+ Hsla, ImageData, InputEvent, IsZero, KeyContext, KeyDispatcher, LayoutId, Model, ModelContext,
+ Modifiers, MonochromeSprite, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Path,
+ Pixels, PlatformAtlas, PlatformDisplay, PlatformInputHandler, PlatformWindow, Point,
+ PolychromeSprite, PromptLevel, Quad, Render, RenderGlyphParams, RenderImageParams,
+ RenderSvgParams, ScaledPixels, SceneBuilder, Shadow, SharedString, Size, Style, SubscriberSet,
+ Subscription, TaffyLayoutEngine, Task, Underline, UnderlineStyle, View, VisualContext,
+ WeakView, WindowBounds, WindowOptions, SUBPIXEL_VARIANTS,
};
use anyhow::{anyhow, Result};
use collections::HashMap;
@@ -60,16 +59,7 @@ pub enum DispatchPhase {
}
type AnyObserver = Box<dyn FnMut(&mut WindowContext) -> bool + 'static>;
-type AnyListener = Box<dyn FnMut(&dyn Any, DispatchPhase, &mut WindowContext) + 'static>;
-type AnyKeyListener = Box<
- dyn Fn(
- &dyn Any,
- &[&KeyBindingContext],
- DispatchPhase,
- &mut WindowContext,
- ) -> Option<Box<dyn Action>>
- + 'static,
->;
+type AnyMouseListener = Box<dyn FnMut(&dyn Any, DispatchPhase, &mut WindowContext) + 'static>;
type AnyFocusListener = Box<dyn Fn(&FocusEvent, &mut WindowContext) + 'static>;
type AnyWindowFocusListener = Box<dyn FnMut(&FocusEvent, &mut WindowContext) -> bool + 'static>;
@@ -97,20 +87,12 @@ impl FocusId {
/// Obtains whether this handle contains the given handle in the most recently rendered frame.
pub(crate) fn contains(&self, other: Self, cx: &WindowContext) -> bool {
- let mut ancestor = Some(other);
- while let Some(ancestor_id) = ancestor {
- if *self == ancestor_id {
- return true;
- } else {
- ancestor = cx
- .window
- .current_frame
- .focus_parents_by_child
- .get(&ancestor_id)
- .copied();
- }
- }
- false
+ cx.window
+ .current_frame
+ .key_dispatcher
+ .as_ref()
+ .unwrap()
+ .focus_contains(*self, other)
}
}
@@ -227,20 +209,31 @@ pub struct Window {
pub(crate) focus: Option<FocusId>,
}
-#[derive(Default)]
+// #[derive(Default)]
pub(crate) struct Frame {
element_states: HashMap<GlobalElementId, AnyBox>,
- key_matchers: HashMap<GlobalElementId, KeystrokeMatcher>,
- mouse_listeners: HashMap<TypeId, Vec<(StackingOrder, AnyListener)>>,
+ mouse_listeners: HashMap<TypeId, Vec<(StackingOrder, AnyMouseListener)>>,
+ pub(crate) key_dispatcher: Option<KeyDispatcher>,
pub(crate) focus_listeners: Vec<AnyFocusListener>,
- pub(crate) key_dispatch_stack: Vec<KeyDispatchStackFrame>,
- freeze_key_dispatch_stack: bool,
- focus_parents_by_child: HashMap<FocusId, FocusId>,
pub(crate) scene_builder: SceneBuilder,
z_index_stack: StackingOrder,
content_mask_stack: Vec<ContentMask<Pixels>>,
element_offset_stack: Vec<Point<Pixels>>,
- focus_stack: Vec<FocusId>,
+}
+
+impl Frame {
+ pub fn new(key_dispatcher: KeyDispatcher) -> Self {
+ Frame {
+ element_states: HashMap::default(),
+ mouse_listeners: HashMap::default(),
+ key_dispatcher: Some(key_dispatcher),
+ focus_listeners: Vec::new(),
+ scene_builder: SceneBuilder::default(),
+ z_index_stack: StackingOrder::default(),
+ content_mask_stack: Vec::new(),
+ element_offset_stack: Vec::new(),
+ }
+ }
}
impl Window {
@@ -309,8 +302,8 @@ impl Window {
layout_engine: TaffyLayoutEngine::new(),
root_view: None,
element_id_stack: GlobalElementId::default(),
- previous_frame: Frame::default(),
- current_frame: Frame::default(),
+ previous_frame: Frame::new(KeyDispatcher::new(cx.keymap.clone())),
+ current_frame: Frame::new(KeyDispatcher::new(cx.keymap.clone())),
focus_handles: Arc::new(RwLock::new(SlotMap::with_key())),
focus_listeners: SubscriberSet::new(),
default_prevented: true,
@@ -328,18 +321,6 @@ impl Window {
}
}
-/// When constructing the element tree, we maintain a stack of key dispatch frames until we
-/// find the focused element. We interleave key listeners with dispatch contexts so we can use the
-/// contexts when matching key events against the keymap. A key listener can be either an action
-/// handler or a [KeyDown] / [KeyUp] event listener.
-pub(crate) enum KeyDispatchStackFrame {
- Listener {
- event_type: TypeId,
- listener: AnyKeyListener,
- },
- Context(KeyBindingContext),
-}
-
/// Indicates which region of the window is visible. Content falling outside of this mask will not be
/// rendered. Currently, only rectangular content masks are supported, but we give the mask its own type
/// to leave room to support more complex shapes in the future.
@@ -407,7 +388,9 @@ impl<'a> WindowContext<'a> {
/// Move focus to the element associated with the given `FocusHandle`.
pub fn focus(&mut self, handle: &FocusHandle) {
- if self.window.focus == Some(handle.id) {
+ let focus_id = handle.id;
+
+ if self.window.focus == Some(focus_id) {
return;
}
@@ -415,13 +398,10 @@ impl<'a> WindowContext<'a> {
self.window.last_blur = Some(self.window.focus);
}
- self.window.focus = Some(handle.id);
-
- // self.window.current_frame.key_dispatch_stack.clear()
- // self.window.root_view.initialize()
+ self.window.focus = Some(focus_id);
self.app.push_effect(Effect::FocusChanged {
window_handle: self.window.handle,
- focused: Some(handle.id),
+ focused: Some(focus_id),
});
self.notify();
}
@@ -441,11 +421,13 @@ impl<'a> WindowContext<'a> {
}
pub fn dispatch_action(&mut self, action: Box<dyn Action>) {
- self.defer(|cx| {
- cx.app.propagate_event = true;
- let stack = cx.dispatch_stack();
- cx.dispatch_action_internal(action, &stack[..])
- })
+ if let Some(focus_handle) = self.focused() {
+ self.defer(move |cx| {
+ let dispatcher = cx.window.current_frame.key_dispatcher.take().unwrap();
+ dispatcher.dispatch_action(focus_handle.id, action, cx);
+ cx.window.current_frame.key_dispatcher = Some(dispatcher);
+ })
+ }
}
/// Schedules the given function to be run at the end of the current effect cycle, allowing entities
@@ -1079,26 +1061,6 @@ impl<'a> WindowContext<'a> {
self.window.dirty = false;
}
- pub(crate) fn dispatch_stack(&mut self) -> Vec<KeyDispatchStackFrame> {
- let root_view = self.window.root_view.take().unwrap();
- let window = &mut *self.window;
- let mut spare_frame = Frame::default();
- mem::swap(&mut spare_frame, &mut window.previous_frame);
-
- self.start_frame();
-
- root_view.draw_dispatch_stack(self);
-
- let window = &mut *self.window;
- // restore the old values of current and previous frame,
- // putting the new frame into spare_frame.
- mem::swap(&mut window.current_frame, &mut window.previous_frame);
- mem::swap(&mut spare_frame, &mut window.previous_frame);
- self.window.root_view = Some(root_view);
-
- spare_frame.key_dispatch_stack
- }
-
/// Rotate the current frame and the previous frame, then clear the current frame.
/// We repopulate all state in the current frame during each paint.
fn start_frame(&mut self) {
@@ -1110,12 +1072,9 @@ impl<'a> WindowContext<'a> {
mem::swap(&mut window.previous_frame, &mut window.current_frame);
let frame = &mut window.current_frame;
frame.element_states.clear();
- frame.key_matchers.clear();
frame.mouse_listeners.values_mut().for_each(Vec::clear);
frame.focus_listeners.clear();
- frame.key_dispatch_stack.clear();
- frame.focus_parents_by_child.clear();
- frame.freeze_key_dispatch_stack = false;
+ frame.key_dispatcher.as_mut().map(KeyDispatcher::clear);
}
/// Dispatch a mouse or keyboard event on the window.
@@ -1226,99 +1185,16 @@ impl<'a> WindowContext<'a> {
.insert(any_mouse_event.type_id(), handlers);
}
} else if let Some(any_key_event) = event.keyboard_event() {
- let key_dispatch_stack = mem::take(&mut self.window.current_frame.key_dispatch_stack);
- let key_event_type = any_key_event.type_id();
- let mut context_stack = SmallVec::<[&KeyBindingContext; 16]>::new();
-
- for (ix, frame) in key_dispatch_stack.iter().enumerate() {
- match frame {
- KeyDispatchStackFrame::Listener {
- event_type,
- listener,
- } => {
- if key_event_type == *event_type {
- if let Some(action) = listener(
- any_key_event,
- &context_stack,
- DispatchPhase::Capture,
- self,
- ) {
- self.dispatch_action_internal(action, &key_dispatch_stack[..ix]);
- }
- if !self.app.propagate_event {
- break;
- }
- }
- }
- KeyDispatchStackFrame::Context(context) => {
- context_stack.push(&context);
- }
- }
+ if let Some(focus_id) = self.window.focus {
+ let mut dispatcher = self.window.current_frame.key_dispatcher.take().unwrap();
+ dispatcher.dispatch_key(focus_id, any_key_event, self);
+ self.window.current_frame.key_dispatcher = Some(dispatcher);
}
-
- if self.app.propagate_event {
- for (ix, frame) in key_dispatch_stack.iter().enumerate().rev() {
- match frame {
- KeyDispatchStackFrame::Listener {
- event_type,
- listener,
- } => {
- if key_event_type == *event_type {
- if let Some(action) = listener(
- any_key_event,
- &context_stack,
- DispatchPhase::Bubble,
- self,
- ) {
- self.dispatch_action_internal(
- action,
- &key_dispatch_stack[..ix],
- );
- }
-
- if !self.app.propagate_event {
- break;
- }
- }
- }
- KeyDispatchStackFrame::Context(_) => {
- context_stack.pop();
- }
- }
- }
- }
-
- drop(context_stack);
- self.window.current_frame.key_dispatch_stack = key_dispatch_stack;
}
!self.app.propagate_event
}
- /// Attempt to map a keystroke to an action based on the keymap.
- pub fn match_keystroke(
- &mut self,
- element_id: &GlobalElementId,
- keystroke: &Keystroke,
- context_stack: &[KeyBindingContext],
- ) -> KeyMatch {
- let key_match = self
- .window
- .current_frame
- .key_matchers
- .get_mut(element_id)
- .unwrap()
- .match_keystroke(keystroke, context_stack);
-
- if key_match.is_some() {
- for matcher in self.window.current_frame.key_matchers.values_mut() {
- matcher.clear_pending();
- }
- }
-
- key_match
- }
-
/// Register the given handler to be invoked whenever the global of the given type
/// is updated.
pub fn observe_global<G: 'static>(
@@ -1345,105 +1221,16 @@ impl<'a> WindowContext<'a> {
self.window.platform_window.prompt(level, msg, answers)
}
- pub fn available_actions(&self) -> impl Iterator<Item = Box<dyn Action>> + '_ {
- let key_dispatch_stack = &self.window.previous_frame.key_dispatch_stack;
- key_dispatch_stack.iter().filter_map(|frame| {
- match frame {
- // todo!factor out a KeyDispatchStackFrame::Action
- KeyDispatchStackFrame::Listener {
- event_type,
- listener: _,
- } => {
- match build_action_from_type(event_type) {
- Ok(action) => Some(action),
- Err(err) => {
- dbg!(err);
- None
- } // we'll hit his if TypeId == KeyDown
- }
- }
- KeyDispatchStackFrame::Context(_) => None,
- }
- })
- }
-
- pub(crate) fn dispatch_action_internal(
- &mut self,
- action: Box<dyn Action>,
- dispatch_stack: &[KeyDispatchStackFrame],
- ) {
- let action_type = action.as_any().type_id();
-
- if let Some(mut global_listeners) = self.app.global_action_listeners.remove(&action_type) {
- for listener in &global_listeners {
- listener(action.as_ref(), DispatchPhase::Capture, self);
- if !self.app.propagate_event {
- break;
- }
- }
- global_listeners.extend(
- self.global_action_listeners
- .remove(&action_type)
- .unwrap_or_default(),
- );
- self.global_action_listeners
- .insert(action_type, global_listeners);
- }
-
- if self.app.propagate_event {
- for stack_frame in dispatch_stack {
- if let KeyDispatchStackFrame::Listener {
- event_type,
- listener,
- } = stack_frame
- {
- if action_type == *event_type {
- listener(action.as_any(), &[], DispatchPhase::Capture, self);
- if !self.app.propagate_event {
- break;
- }
- }
- }
- }
- }
-
- if self.app.propagate_event {
- for stack_frame in dispatch_stack.iter().rev() {
- if let KeyDispatchStackFrame::Listener {
- event_type,
- listener,
- } = stack_frame
- {
- if action_type == *event_type {
- self.app.propagate_event = false;
- listener(action.as_any(), &[], DispatchPhase::Bubble, self);
- if !self.app.propagate_event {
- break;
- }
- }
- }
- }
- }
-
- if self.app.propagate_event {
- if let Some(mut global_listeners) =
- self.app.global_action_listeners.remove(&action_type)
- {
- for listener in global_listeners.iter().rev() {
- self.app.propagate_event = false;
- listener(action.as_ref(), DispatchPhase::Bubble, self);
- if !self.app.propagate_event {
- break;
- }
- }
- global_listeners.extend(
- self.global_action_listeners
- .remove(&action_type)
- .unwrap_or_default(),
- );
- self.global_action_listeners
- .insert(action_type, global_listeners);
- }
+ pub fn available_actions(&self) -> Vec<Box<dyn Action>> {
+ if let Some(focus_id) = self.window.focus {
+ self.window
+ .current_frame
+ .key_dispatcher
+ .as_ref()
+ .unwrap()
+ .available_actions(focus_id)
+ } else {
+ Vec::new()
}
}
}
@@ -1609,22 +1396,9 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
id: impl Into<ElementId>,
f: impl FnOnce(GlobalElementId, &mut Self) -> R,
) -> R {
- let keymap = self.app_mut().keymap.clone();
let window = self.window_mut();
window.element_id_stack.push(id.into());
let global_id = window.element_id_stack.clone();
-
- if window.current_frame.key_matchers.get(&global_id).is_none() {
- window.current_frame.key_matchers.insert(
- global_id.clone(),
- window
- .previous_frame
- .key_matchers
- .remove(&global_id)
- .unwrap_or_else(|| KeystrokeMatcher::new(keymap)),
- );
- }
-
let result = f(global_id, self);
let window: &mut Window = self.borrow_mut();
window.element_id_stack.pop();
@@ -2109,94 +1883,25 @@ impl<'a, V: 'static> ViewContext<'a, V> {
}));
}
- pub fn with_key_listeners<R>(
+ pub fn with_key_dispatch<R>(
&mut self,
- key_listeners: impl IntoIterator<Item = (TypeId, KeyListener<V>)>,
- f: impl FnOnce(&mut Self) -> R,
+ context: KeyContext,
+ focus_handle: Option<FocusHandle>,
+ f: impl FnOnce(Option<FocusHandle>, &mut Self) -> R,
) -> R {
- let old_stack_len = self.window.current_frame.key_dispatch_stack.len();
- if !self.window.current_frame.freeze_key_dispatch_stack {
- for (event_type, listener) in key_listeners {
- let handle = self.view().downgrade();
- let listener = Box::new(
- move |event: &dyn Any,
- context_stack: &[&KeyBindingContext],
- phase: DispatchPhase,
- cx: &mut WindowContext<'_>| {
- handle
- .update(cx, |view, cx| {
- listener(view, event, context_stack, phase, cx)
- })
- .log_err()
- .flatten()
- },
- );
- self.window.current_frame.key_dispatch_stack.push(
- KeyDispatchStackFrame::Listener {
- event_type,
- listener,
- },
- );
- }
- }
+ let mut old_dispatcher = self.window.previous_frame.key_dispatcher.take().unwrap();
+ let mut current_dispatcher = self.window.current_frame.key_dispatcher.take().unwrap();
- let result = f(self);
-
- if !self.window.current_frame.freeze_key_dispatch_stack {
- self.window
- .current_frame
- .key_dispatch_stack
- .truncate(old_stack_len);
- }
-
- result
- }
-
- pub fn with_key_dispatch_context<R>(
- &mut self,
- context: KeyBindingContext,
- f: impl FnOnce(&mut Self) -> R,
- ) -> R {
- if context.is_empty() {
- return f(self);
- }
-
- if !self.window.current_frame.freeze_key_dispatch_stack {
- self.window
- .current_frame
- .key_dispatch_stack
- .push(KeyDispatchStackFrame::Context(context));
+ current_dispatcher.push_node(context, &mut old_dispatcher);
+ if let Some(focus_handle) = focus_handle.as_ref() {
+ current_dispatcher.make_focusable(focus_handle.id);
}
+ let result = f(focus_handle, self);
+ current_dispatcher.pop_node();
- let result = f(self);
-
- if !self.window.previous_frame.freeze_key_dispatch_stack {
- self.window.previous_frame.key_dispatch_stack.pop();
- }
-
- result
- }
-
- pub fn with_focus<R>(
- &mut self,
- focus_handle: FocusHandle,
- f: impl FnOnce(&mut Self) -> R,
- ) -> R {
- if let Some(parent_focus_id) = self.window.current_frame.focus_stack.last().copied() {
- self.window
- .current_frame
- .focus_parents_by_child
- .insert(focus_handle.id, parent_focus_id);
- }
- self.window.current_frame.focus_stack.push(focus_handle.id);
-
- if Some(focus_handle.id) == self.window.focus {
- self.window.current_frame.freeze_key_dispatch_stack = true;
- }
-
- let result = f(self);
+ self.window.previous_frame.key_dispatcher = Some(old_dispatcher);
+ self.window.current_frame.key_dispatcher = Some(current_dispatcher);
- self.window.current_frame.focus_stack.pop();
result
}
@@ -1,8 +1,8 @@
use editor::Editor;
use gpui::{
- div, uniform_list, Component, Div, FocusEnabled, ParentElement, Render, StatefulInteractivity,
- StatelessInteractive, Styled, Task, UniformListScrollHandle, View, ViewContext, VisualContext,
- WindowContext,
+ div, uniform_list, Component, Div, FocusableKeyDispatch, ParentElement, Render,
+ StatefulInteractivity, StatelessInteractive, Styled, Task, UniformListScrollHandle, View,
+ ViewContext, VisualContext, WindowContext,
};
use std::cmp;
use theme::ActiveTheme;
@@ -137,7 +137,7 @@ impl<D: PickerDelegate> Picker<D> {
}
impl<D: PickerDelegate> Render for Picker<D> {
- type Element = Div<Self, StatefulInteractivity<Self>, FocusEnabled<Self>>;
+ type Element = Div<Self, StatefulInteractivity<Self>, FocusableKeyDispatch<Self>>;
fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
div()
@@ -1,5 +1,5 @@
use gpui::{
- actions, div, Div, FocusEnabled, Focusable, KeyBinding, ParentElement, Render,
+ actions, div, Div, Focusable, FocusableKeyDispatch, KeyBinding, ParentElement, Render,
StatefulInteractivity, StatelessInteractive, Styled, View, VisualContext, WindowContext,
};
use theme2::ActiveTheme;
@@ -21,7 +21,7 @@ impl FocusStory {
}
impl Render for FocusStory {
- type Element = Div<Self, StatefulInteractivity<Self>, FocusEnabled<Self>>;
+ type Element = Div<Self, StatefulInteractivity<Self>, FocusableKeyDispatch<Self>>;
fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> Self::Element {
let theme = cx.theme();
@@ -1,4 +1,4 @@
-use gpui::{Div, ElementFocus, ElementInteractivity, Styled};
+use gpui::{Div, ElementInteractivity, KeyDispatch, Styled};
use crate::UITextSize;
@@ -69,6 +69,6 @@ pub trait StyledExt: Styled {
impl<V, I, F> StyledExt for Div<V, I, F>
where
I: ElementInteractivity<V>,
- F: ElementFocus<V>,
+ F: KeyDispatch<V>,
{
}
@@ -38,10 +38,10 @@ use futures::{
use gpui::{
actions, div, point, rems, size, Action, AnyModel, AnyView, AnyWeakView, AppContext,
AsyncAppContext, AsyncWindowContext, Bounds, Component, Div, Entity, EntityId, EventEmitter,
- FocusHandle, GlobalPixels, KeyBindingContext, Model, ModelContext, ParentElement, Point,
- Render, Size, StatefulInteractive, StatefulInteractivity, StatelessInteractive, Styled,
- Subscription, Task, View, ViewContext, VisualContext, WeakView, WindowBounds, WindowContext,
- WindowHandle, WindowOptions,
+ FocusHandle, GlobalPixels, KeyContext, Model, ModelContext, ParentElement, Point, Render, Size,
+ StatefulInteractive, StatefulInteractivity, StatelessInteractive, Styled, Subscription, Task,
+ View, ViewContext, VisualContext, WeakView, WindowBounds, WindowContext, WindowHandle,
+ WindowOptions,
};
use item::{FollowableItem, FollowableItemHandle, Item, ItemHandle, ItemSettings, ProjectItem};
use itertools::Itertools;
@@ -3743,158 +3743,158 @@ impl Render for Workspace {
type Element = Div<Self>;
fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
- let mut context = KeyBindingContext::default();
+ let mut context = KeyContext::default();
context.add("Workspace");
- cx.with_key_dispatch_context(context, |cx| {
- div()
- .relative()
- .size_full()
- .flex()
- .flex_col()
- .font("Zed Sans")
- .gap_0()
- .justify_start()
- .items_start()
- .text_color(cx.theme().colors().text)
- .bg(cx.theme().colors().background)
- .child(self.render_titlebar(cx))
- .child(
- // todo! should this be a component a view?
- self.add_workspace_actions_listeners(div().id("workspace"))
- .relative()
- .flex_1()
- .w_full()
- .flex()
- .overflow_hidden()
- .border_t()
- .border_b()
- .border_color(cx.theme().colors().border)
- .child(self.modal_layer.clone())
- // .children(
- // Some(
- // Panel::new("project-panel-outer", cx)
- // .side(PanelSide::Left)
- // .child(ProjectPanel::new("project-panel-inner")),
- // )
- // .filter(|_| self.is_project_panel_open()),
- // )
- // .children(
- // Some(
- // Panel::new("collab-panel-outer", cx)
- // .child(CollabPanel::new("collab-panel-inner"))
- // .side(PanelSide::Left),
- // )
- // .filter(|_| self.is_collab_panel_open()),
- // )
- // .child(NotificationToast::new(
- // "maxbrunsfeld has requested to add you as a contact.".into(),
- // ))
- .child(
- div().flex().flex_col().flex_1().h_full().child(
- div().flex().flex_1().child(self.center.render(
- &self.project,
- &self.follower_states,
- self.active_call(),
- &self.active_pane,
- self.zoomed.as_ref(),
- &self.app_state,
- cx,
- )),
- ), // .children(
- // Some(
- // Panel::new("terminal-panel", cx)
- // .child(Terminal::new())
- // .allowed_sides(PanelAllowedSides::BottomOnly)
- // .side(PanelSide::Bottom),
- // )
- // .filter(|_| self.is_terminal_open()),
- // ),
+
+ div()
+ .context(context)
+ .relative()
+ .size_full()
+ .flex()
+ .flex_col()
+ .font("Zed Sans")
+ .gap_0()
+ .justify_start()
+ .items_start()
+ .text_color(cx.theme().colors().text)
+ .bg(cx.theme().colors().background)
+ .child(self.render_titlebar(cx))
+ .child(
+ // todo! should this be a component a view?
+ self.add_workspace_actions_listeners(div().id("workspace"))
+ .relative()
+ .flex_1()
+ .w_full()
+ .flex()
+ .overflow_hidden()
+ .border_t()
+ .border_b()
+ .border_color(cx.theme().colors().border)
+ .child(self.modal_layer.clone())
+ // .children(
+ // Some(
+ // Panel::new("project-panel-outer", cx)
+ // .side(PanelSide::Left)
+ // .child(ProjectPanel::new("project-panel-inner")),
+ // )
+ // .filter(|_| self.is_project_panel_open()),
+ // )
+ // .children(
+ // Some(
+ // Panel::new("collab-panel-outer", cx)
+ // .child(CollabPanel::new("collab-panel-inner"))
+ // .side(PanelSide::Left),
+ // )
+ // .filter(|_| self.is_collab_panel_open()),
+ // )
+ // .child(NotificationToast::new(
+ // "maxbrunsfeld has requested to add you as a contact.".into(),
+ // ))
+ .child(
+ div().flex().flex_col().flex_1().h_full().child(
+ div().flex().flex_1().child(self.center.render(
+ &self.project,
+ &self.follower_states,
+ self.active_call(),
+ &self.active_pane,
+ self.zoomed.as_ref(),
+ &self.app_state,
+ cx,
+ )),
), // .children(
// Some(
- // Panel::new("chat-panel-outer", cx)
- // .side(PanelSide::Right)
- // .child(ChatPanel::new("chat-panel-inner").messages(vec![
- // ChatMessage::new(
- // "osiewicz".to_string(),
- // "is this thing on?".to_string(),
- // DateTime::parse_from_rfc3339("2023-09-27T15:40:52.707Z")
- // .unwrap()
- // .naive_local(),
- // ),
- // ChatMessage::new(
- // "maxdeviant".to_string(),
- // "Reading you loud and clear!".to_string(),
- // DateTime::parse_from_rfc3339("2023-09-28T15:40:52.707Z")
- // .unwrap()
- // .naive_local(),
- // ),
- // ])),
- // )
- // .filter(|_| self.is_chat_panel_open()),
- // )
- // .children(
- // Some(
- // Panel::new("notifications-panel-outer", cx)
- // .side(PanelSide::Right)
- // .child(NotificationsPanel::new("notifications-panel-inner")),
- // )
- // .filter(|_| self.is_notifications_panel_open()),
- // )
- // .children(
- // Some(
- // Panel::new("assistant-panel-outer", cx)
- // .child(AssistantPanel::new("assistant-panel-inner")),
+ // Panel::new("terminal-panel", cx)
+ // .child(Terminal::new())
+ // .allowed_sides(PanelAllowedSides::BottomOnly)
+ // .side(PanelSide::Bottom),
// )
- // .filter(|_| self.is_assistant_panel_open()),
+ // .filter(|_| self.is_terminal_open()),
// ),
- )
- .child(self.status_bar.clone())
- // .when(self.debug.show_toast, |this| {
- // this.child(Toast::new(ToastOrigin::Bottom).child(Label::new("A toast")))
- // })
- // .children(
- // Some(
- // div()
- // .absolute()
- // .top(px(50.))
- // .left(px(640.))
- // .z_index(8)
- // .child(LanguageSelector::new("language-selector")),
- // )
- // .filter(|_| self.is_language_selector_open()),
- // )
- .z_index(8)
- // Debug
- .child(
- div()
- .flex()
- .flex_col()
- .z_index(9)
- .absolute()
- .top_20()
- .left_1_4()
- .w_40()
- .gap_2(), // .when(self.show_debug, |this| {
- // this.child(Button::<Workspace>::new("Toggle User Settings").on_click(
- // Arc::new(|workspace, cx| workspace.debug_toggle_user_settings(cx)),
- // ))
- // .child(
- // Button::<Workspace>::new("Toggle Toasts").on_click(Arc::new(
- // |workspace, cx| workspace.debug_toggle_toast(cx),
- // )),
- // )
- // .child(
- // Button::<Workspace>::new("Toggle Livestream").on_click(Arc::new(
- // |workspace, cx| workspace.debug_toggle_livestream(cx),
- // )),
- // )
- // })
- // .child(
- // Button::<Workspace>::new("Toggle Debug")
- // .on_click(Arc::new(|workspace, cx| workspace.toggle_debug(cx))),
- // ),
- )
- })
+ ), // .children(
+ // Some(
+ // Panel::new("chat-panel-outer", cx)
+ // .side(PanelSide::Right)
+ // .child(ChatPanel::new("chat-panel-inner").messages(vec![
+ // ChatMessage::new(
+ // "osiewicz".to_string(),
+ // "is this thing on?".to_string(),
+ // DateTime::parse_from_rfc3339("2023-09-27T15:40:52.707Z")
+ // .unwrap()
+ // .naive_local(),
+ // ),
+ // ChatMessage::new(
+ // "maxdeviant".to_string(),
+ // "Reading you loud and clear!".to_string(),
+ // DateTime::parse_from_rfc3339("2023-09-28T15:40:52.707Z")
+ // .unwrap()
+ // .naive_local(),
+ // ),
+ // ])),
+ // )
+ // .filter(|_| self.is_chat_panel_open()),
+ // )
+ // .children(
+ // Some(
+ // Panel::new("notifications-panel-outer", cx)
+ // .side(PanelSide::Right)
+ // .child(NotificationsPanel::new("notifications-panel-inner")),
+ // )
+ // .filter(|_| self.is_notifications_panel_open()),
+ // )
+ // .children(
+ // Some(
+ // Panel::new("assistant-panel-outer", cx)
+ // .child(AssistantPanel::new("assistant-panel-inner")),
+ // )
+ // .filter(|_| self.is_assistant_panel_open()),
+ // ),
+ )
+ .child(self.status_bar.clone())
+ // .when(self.debug.show_toast, |this| {
+ // this.child(Toast::new(ToastOrigin::Bottom).child(Label::new("A toast")))
+ // })
+ // .children(
+ // Some(
+ // div()
+ // .absolute()
+ // .top(px(50.))
+ // .left(px(640.))
+ // .z_index(8)
+ // .child(LanguageSelector::new("language-selector")),
+ // )
+ // .filter(|_| self.is_language_selector_open()),
+ // )
+ .z_index(8)
+ // Debug
+ .child(
+ div()
+ .flex()
+ .flex_col()
+ .z_index(9)
+ .absolute()
+ .top_20()
+ .left_1_4()
+ .w_40()
+ .gap_2(), // .when(self.show_debug, |this| {
+ // this.child(Button::<Workspace>::new("Toggle User Settings").on_click(
+ // Arc::new(|workspace, cx| workspace.debug_toggle_user_settings(cx)),
+ // ))
+ // .child(
+ // Button::<Workspace>::new("Toggle Toasts").on_click(Arc::new(
+ // |workspace, cx| workspace.debug_toggle_toast(cx),
+ // )),
+ // )
+ // .child(
+ // Button::<Workspace>::new("Toggle Livestream").on_click(Arc::new(
+ // |workspace, cx| workspace.debug_toggle_livestream(cx),
+ // )),
+ // )
+ // })
+ // .child(
+ // Button::<Workspace>::new("Toggle Debug")
+ // .on_click(Arc::new(|workspace, cx| workspace.toggle_debug(cx))),
+ // ),
+ )
}
}
// todo!()