Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'main' into picker-actions

Browse source
This commit is contained in:
Max Brunsfeld 2023-11-08 10:49:44 -08:00
commit 2ac28240e4
4 changed files with 137 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

13
.github/workflows/ci.yml vendored
View file

@ -32,7 +32,7 @@ jobs:
uses: actions/checkout@v3
with:
clean: false
submodules: 'recursive'
submodules: "recursive"
- name: cargo fmt
run: cargo fmt --all -- --check
@ -56,13 +56,13 @@ jobs:
- name: Install Node
uses: actions/setup-node@v3
with:
node-version: '18'
node-version: "18"
- name: Checkout repo
uses: actions/checkout@v3
with:
clean: false
submodules: 'recursive'
submodules: "recursive"
- name: Limit target directory size
run: script/clear-target-dir-if-larger-than 70
@ -79,9 +79,6 @@ jobs:
- name: Build other binaries
run: cargo build --workspace --bins --all-features
- name: Generate license file
run: script/generate-licenses
bundle:
name: Bundle app
runs-on:
@ -106,13 +103,13 @@ jobs:
- name: Install Node
uses: actions/setup-node@v3
with:
node-version: '18'
node-version: "18"
- name: Checkout repo
uses: actions/checkout@v3
with:
clean: false
submodules: 'recursive'
submodules: "recursive"
- name: Limit target directory size
run: script/clear-target-dir-if-larger-than 70

6
crates/gpui2/src/app.rs
View file

@ -519,7 +519,7 @@ impl AppContext {
window_handle
.update(self, |_, cx| {
if cx.window.focus == focused {
let mut listeners = mem::take(&mut cx.window.focus_listeners);
let mut listeners = mem::take(&mut cx.window.current_frame.focus_listeners);
let focused = focused
.map(|id| FocusHandle::for_id(id, &cx.window.focus_handles).unwrap());
let blurred = cx
@ -535,8 +535,8 @@ impl AppContext {
}
}
listeners.extend(cx.window.focus_listeners.drain(..));
cx.window.focus_listeners = listeners;
listeners.extend(cx.window.current_frame.focus_listeners.drain(..));
cx.window.current_frame.focus_listeners = listeners;
}
})
.ok();

6
crates/gpui2/src/scene.rs
View file

@ -27,8 +27,8 @@ pub(crate) struct SceneBuilder {
polychrome_sprites: Vec<PolychromeSprite>,
}
impl SceneBuilder {
pub fn new() -> SceneBuilder {
impl Default for SceneBuilder {
fn default() -> Self {
SceneBuilder {
layers_by_order: BTreeMap::new(),
splitter: BspSplitter::new(),
@ -40,7 +40,9 @@ impl SceneBuilder {
polychrome_sprites: Vec::new(),
}
}
}
impl SceneBuilder {
pub fn build(&mut self) -> Scene {
// Map each layer id to a float between 0. and 1., with 1. closer to the viewer.
let mut layer_z_values = vec![0.; self.layers_by_order.len()];

238
crates/gpui2/src/window.rs
View file

@ -132,7 +132,12 @@ impl FocusHandle {
if self.id == ancestor_id {
return true;
} else {
ancestor = cx.window.focus_parents_by_child.get(&ancestor_id).copied();
ancestor = cx
.window
.current_frame
.focus_parents_by_child
.get(&ancestor_id)
.copied();
}
}
false
@ -175,19 +180,8 @@ pub struct Window {
pub(crate) layout_engine: TaffyLayoutEngine,
pub(crate) root_view: Option<AnyView>,
pub(crate) element_id_stack: GlobalElementId,
prev_frame_element_states: HashMap<GlobalElementId, AnyBox>,
element_states: HashMap<GlobalElementId, AnyBox>,
prev_frame_key_matchers: HashMap<GlobalElementId, KeyMatcher>,
key_matchers: HashMap<GlobalElementId, KeyMatcher>,
z_index_stack: StackingOrder,
content_mask_stack: Vec<ContentMask<Pixels>>,
element_offset_stack: Vec<Point<Pixels>>,
mouse_listeners: HashMap<TypeId, Vec<(StackingOrder, AnyListener)>>,
key_dispatch_stack: Vec<KeyDispatchStackFrame>,
freeze_key_dispatch_stack: bool,
focus_stack: Vec<FocusId>,
focus_parents_by_child: HashMap<FocusId, FocusId>,
pub(crate) focus_listeners: Vec<AnyFocusListener>,
pub(crate) previous_frame: Frame,
pub(crate) current_frame: Frame,
pub(crate) focus_handles: Arc<RwLock<SlotMap<FocusId, AtomicUsize>>>,
default_prevented: bool,
mouse_position: Point<Pixels>,
@ -198,12 +192,27 @@ pub struct Window {
bounds_observers: SubscriberSet<(), AnyObserver>,
active: bool,
activation_observers: SubscriberSet<(), AnyObserver>,
pub(crate) scene_builder: SceneBuilder,
pub(crate) dirty: bool,
pub(crate) last_blur: Option<Option<FocusId>>,
pub(crate) focus: Option<FocusId>,
}
#[derive(Default)]
pub(crate) struct Frame {
element_states: HashMap<GlobalElementId, AnyBox>,
key_matchers: HashMap<GlobalElementId, KeyMatcher>,
mouse_listeners: HashMap<TypeId, Vec<(StackingOrder, AnyListener)>>,
pub(crate) focus_listeners: Vec<AnyFocusListener>,
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 Window {
pub(crate) fn new(
handle: AnyWindowHandle,
@ -270,19 +279,8 @@ impl Window {
layout_engine: TaffyLayoutEngine::new(),
root_view: None,
element_id_stack: GlobalElementId::default(),
prev_frame_element_states: HashMap::default(),
element_states: HashMap::default(),
prev_frame_key_matchers: HashMap::default(),
key_matchers: HashMap::default(),
z_index_stack: StackingOrder(SmallVec::new()),
content_mask_stack: Vec::new(),
element_offset_stack: Vec::new(),
mouse_listeners: HashMap::default(),
key_dispatch_stack: Vec::new(),
freeze_key_dispatch_stack: false,
focus_stack: Vec::new(),
focus_parents_by_child: HashMap::default(),
focus_listeners: Vec::new(),
previous_frame: Frame::default(),
current_frame: Frame::default(),
focus_handles: Arc::new(RwLock::new(SlotMap::with_key())),
default_prevented: true,
mouse_position,
@ -293,7 +291,6 @@ impl Window {
bounds_observers: SubscriberSet::new(),
active: false,
activation_observers: SubscriberSet::new(),
scene_builder: SceneBuilder::new(),
dirty: true,
last_blur: None,
focus: None,
@ -667,8 +664,9 @@ impl<'a> WindowContext<'a> {
&mut self,
handler: impl Fn(&Event, DispatchPhase, &mut WindowContext) + 'static,
) {
let order = self.window.z_index_stack.clone();
let order = self.window.current_frame.z_index_stack.clone();
self.window
.current_frame
.mouse_listeners
.entry(TypeId::of::<Event>())
.or_default()
@ -692,9 +690,9 @@ impl<'a> WindowContext<'a> {
/// Called during painting to invoke the given closure in a new stacking context. The given
/// z-index is interpreted relative to the previous call to `stack`.
pub fn stack<R>(&mut self, z_index: u32, f: impl FnOnce(&mut Self) -> R) -> R {
self.window.z_index_stack.push(z_index);
self.window.current_frame.z_index_stack.push(z_index);
let result = f(self);
self.window.z_index_stack.pop();
self.window.current_frame.z_index_stack.pop();
result
}
@ -712,8 +710,8 @@ impl<'a> WindowContext<'a> {
let mut shadow_bounds = bounds;
shadow_bounds.origin += shadow.offset;
shadow_bounds.dilate(shadow.spread_radius);
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
Shadow {
order: 0,
bounds: shadow_bounds.scale(scale_factor),
@ -740,8 +738,8 @@ impl<'a> WindowContext<'a> {
let content_mask = self.content_mask();
let window = &mut *self.window;
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
Quad {
order: 0,
bounds: bounds.scale(scale_factor),
@ -761,9 +759,10 @@ impl<'a> WindowContext<'a> {
path.content_mask = content_mask;
path.color = color.into();
let window = &mut *self.window;
window
.scene_builder
.insert(&window.z_index_stack, path.scale(scale_factor));
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
path.scale(scale_factor),
);
}
/// Paint an underline into the scene for the current frame at the current z-index.
@ -785,8 +784,8 @@ impl<'a> WindowContext<'a> {
};
let content_mask = self.content_mask();
let window = &mut *self.window;
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
Underline {
order: 0,
bounds: bounds.scale(scale_factor),
@ -839,8 +838,8 @@ impl<'a> WindowContext<'a> {
};
let content_mask = self.content_mask().scale(scale_factor);
let window = &mut *self.window;
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
MonochromeSprite {
order: 0,
bounds,
@ -890,8 +889,8 @@ impl<'a> WindowContext<'a> {
let content_mask = self.content_mask().scale(scale_factor);
let window = &mut *self.window;
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
PolychromeSprite {
order: 0,
bounds,
@ -932,8 +931,8 @@ impl<'a> WindowContext<'a> {
let content_mask = self.content_mask().scale(scale_factor);
let window = &mut *self.window;
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
MonochromeSprite {
order: 0,
bounds,
@ -968,8 +967,8 @@ impl<'a> WindowContext<'a> {
let corner_radii = corner_radii.scale(scale_factor);
let window = &mut *self.window;
window.scene_builder.insert(
&window.z_index_stack,
window.current_frame.scene_builder.insert(
&window.current_frame.z_index_stack,
PolychromeSprite {
order: 0,
bounds,
@ -1014,7 +1013,7 @@ impl<'a> WindowContext<'a> {
}
self.window.root_view = Some(root_view);
let scene = self.window.scene_builder.build();
let scene = self.window.current_frame.scene_builder.build();
self.window.platform_window.draw(scene);
let cursor_style = self
@ -1030,39 +1029,21 @@ impl<'a> WindowContext<'a> {
self.window.dirty = false;
}
/// 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) {
self.text_system().start_frame();
let window = &mut *self.window;
// Move the current frame element states to the previous frame.
// The new empty element states map will be populated for any element states we
// reference during the upcoming frame.
mem::swap(
&mut window.element_states,
&mut window.prev_frame_element_states,
);
window.element_states.clear();
// Make the current key matchers the previous, and then clear the current.
// An empty key matcher map will be created for every identified element in the
// upcoming frame.
mem::swap(
&mut window.key_matchers,
&mut window.prev_frame_key_matchers,
);
window.key_matchers.clear();
// Clear mouse event listeners, because elements add new element listeners
// when the upcoming frame is painted.
window.mouse_listeners.values_mut().for_each(Vec::clear);
// Clear focus state, because we determine what is focused when the new elements
// in the upcoming frame are initialized.
window.focus_listeners.clear();
window.key_dispatch_stack.clear();
window.focus_parents_by_child.clear();
window.freeze_key_dispatch_stack = false;
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;
}
/// Dispatch a mouse or keyboard event on the window.
@ -1126,6 +1107,7 @@ impl<'a> WindowContext<'a> {
if let Some(any_mouse_event) = event.mouse_event() {
if let Some(mut handlers) = self
.window
.current_frame
.mouse_listeners
.remove(&any_mouse_event.type_id())
{
@ -1160,17 +1142,19 @@ impl<'a> WindowContext<'a> {
// Just in case any handlers added new handlers, which is weird, but possible.
handlers.extend(
self.window
.current_frame
.mouse_listeners
.get_mut(&any_mouse_event.type_id())
.into_iter()
.flat_map(|handlers| handlers.drain(..)),
);
self.window
.current_frame
.mouse_listeners
.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.key_dispatch_stack);
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::<[&DispatchContext; 16]>::new();
@ -1230,7 +1214,7 @@ impl<'a> WindowContext<'a> {
}
drop(context_stack);
self.window.key_dispatch_stack = key_dispatch_stack;
self.window.current_frame.key_dispatch_stack = key_dispatch_stack;
}
!self.app.propagate_event
@ -1245,13 +1229,14 @@ impl<'a> WindowContext<'a> {
) -> 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.key_matchers.values_mut() {
for matcher in self.window.current_frame.key_matchers.values_mut() {
matcher.clear_pending();
}
}
@ -1511,11 +1496,12 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
window.element_id_stack.push(id.into());
let global_id = window.element_id_stack.clone();
if window.key_matchers.get(&global_id).is_none() {
window.key_matchers.insert(
if window.current_frame.key_matchers.get(&global_id).is_none() {
window.current_frame.key_matchers.insert(
global_id.clone(),
window
.prev_frame_key_matchers
.previous_frame
.key_matchers
.remove(&global_id)
.unwrap_or_else(|| KeyMatcher::new(keymap)),
);
@ -1535,9 +1521,12 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
f: impl FnOnce(&mut Self) -> R,
) -> R {
let mask = mask.intersect(&self.content_mask());
self.window_mut().content_mask_stack.push(mask);
self.window_mut()
.current_frame
.content_mask_stack
.push(mask);
let result = f(self);
self.window_mut().content_mask_stack.pop();
self.window_mut().current_frame.content_mask_stack.pop();
result
}
@ -1553,15 +1542,19 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
};
let offset = self.element_offset() + offset;
self.window_mut().element_offset_stack.push(offset);
self.window_mut()
.current_frame
.element_offset_stack
.push(offset);
let result = f(self);
self.window_mut().element_offset_stack.pop();
self.window_mut().current_frame.element_offset_stack.pop();
result
}
/// Obtain the current element offset.
fn element_offset(&self) -> Point<Pixels> {
self.window()
.current_frame
.element_offset_stack
.last()
.copied()
@ -1583,9 +1576,15 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
self.with_element_id(id, |global_id, cx| {
if let Some(any) = cx
.window_mut()
.current_frame
.element_states
.remove(&global_id)
.or_else(|| cx.window_mut().prev_frame_element_states.remove(&global_id))
.or_else(|| {
cx.window_mut()
.previous_frame
.element_states
.remove(&global_id)
})
{
// Using the extra inner option to avoid needing to reallocate a new box.
let mut state_box = any
@ -1596,11 +1595,15 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
.expect("element state is already on the stack");
let (result, state) = f(Some(state), cx);
state_box.replace(state);
cx.window_mut().element_states.insert(global_id, state_box);
cx.window_mut()
.current_frame
.element_states
.insert(global_id, state_box);
result
} else {
let (result, state) = f(None, cx);
cx.window_mut()
.current_frame
.element_states
.insert(global_id, Box::new(Some(state)));
result
@ -1628,6 +1631,7 @@ pub trait BorrowWindow: BorrowMut<Window> + BorrowMut<AppContext> {
/// Obtain the current content mask.
fn content_mask(&self) -> ContentMask<Pixels> {
self.window()
.current_frame
.content_mask_stack
.last()
.cloned()
@ -1712,9 +1716,9 @@ impl<'a, V: 'static> ViewContext<'a, V> {
}
pub fn with_z_index<R>(&mut self, z_index: u32, f: impl FnOnce(&mut Self) -> R) -> R {
self.window.z_index_stack.push(z_index);
self.window.current_frame.z_index_stack.push(z_index);
let result = f(self);
self.window.z_index_stack.pop();
self.window.current_frame.z_index_stack.pop();
result
}
@ -1869,11 +1873,14 @@ impl<'a, V: 'static> ViewContext<'a, V> {
listener: impl Fn(&mut V, &FocusEvent, &mut ViewContext<V>) + 'static,
) {
let handle = self.view().downgrade();
self.window.focus_listeners.push(Box::new(move |event, cx| {
handle
.update(cx, |view, cx| listener(view, event, cx))
.log_err();
}));
self.window
.current_frame
.focus_listeners
.push(Box::new(move |event, cx| {
handle
.update(cx, |view, cx| listener(view, event, cx))
.log_err();
}));
}
pub fn with_key_listeners<R>(
@ -1881,8 +1888,8 @@ impl<'a, V: 'static> ViewContext<'a, V> {
key_listeners: impl IntoIterator<Item = (TypeId, KeyListener<V>)>,
f: impl FnOnce(&mut Self) -> R,
) -> R {
let old_stack_len = self.window.key_dispatch_stack.len();
if !self.window.freeze_key_dispatch_stack {
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(
@ -1898,19 +1905,22 @@ impl<'a, V: 'static> ViewContext<'a, V> {
.flatten()
},
);
self.window
.key_dispatch_stack
.push(KeyDispatchStackFrame::Listener {
self.window.current_frame.key_dispatch_stack.push(
KeyDispatchStackFrame::Listener {
event_type,
listener,
});
},
);
}
}
let result = f(self);
if !self.window.freeze_key_dispatch_stack {
self.window.key_dispatch_stack.truncate(old_stack_len);
if !self.window.current_frame.freeze_key_dispatch_stack {
self.window
.current_frame
.key_dispatch_stack
.truncate(old_stack_len);
}
result
@ -1925,16 +1935,17 @@ impl<'a, V: 'static> ViewContext<'a, V> {
return f(self);
}
if !self.window.freeze_key_dispatch_stack {
if !self.window.current_frame.freeze_key_dispatch_stack {
self.window
.current_frame
.key_dispatch_stack
.push(KeyDispatchStackFrame::Context(context));
}
let result = f(self);
if !self.window.freeze_key_dispatch_stack {
self.window.key_dispatch_stack.pop();
if !self.window.previous_frame.freeze_key_dispatch_stack {
self.window.previous_frame.key_dispatch_stack.pop();
}
result
@ -1945,20 +1956,21 @@ impl<'a, V: 'static> ViewContext<'a, V> {
focus_handle: FocusHandle,
f: impl FnOnce(&mut Self) -> R,
) -> R {
if let Some(parent_focus_id) = self.window.focus_stack.last().copied() {
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.focus_stack.push(focus_handle.id);
self.window.current_frame.focus_stack.push(focus_handle.id);
if Some(focus_handle.id) == self.window.focus {
self.window.freeze_key_dispatch_stack = true;
self.window.current_frame.freeze_key_dispatch_stack = true;
}
let result = f(self);
self.window.focus_stack.pop();
self.window.current_frame.focus_stack.pop();
result
}