Make View Sync as well

Author: gyscos

cursive-core/src/builder.rs

@@ -72,8 +72,9 @@ pub use self::resolvable::{NoConfig, Resolvable};
 
 use crate::views::BoxedView;
 
+use parking_lot::Mutex;
 use std::collections::{HashMap, HashSet};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use std::any::Any;
 
@@ -140,7 +141,7 @@ struct Blueprints {
 }
 
 /// Wrapper around a value that makes it Cloneable, but can only be resolved once.
-pub struct ResolveOnce<T>(std::sync::Arc<std::sync::Mutex<Option<T>>>);
+pub struct ResolveOnce<T>(Arc<Mutex<Option<T>>>);
 
 /// Return a variable-maker (for use in store_with)
 pub fn resolve_once<T>(value: T) -> impl Fn(&Config, &Context) -> Result<T, Error>
@@ -151,7 +152,6 @@ where
     move |_, _| {
         value
             .lock()
-            .unwrap()
             .take()
             .ok_or_else(|| Error::MakerFailed("variable was already resolved".to_string()))
     }
@@ -160,17 +160,17 @@ where
 impl<T> ResolveOnce<T> {
     /// Create a new `ResolveOnce` which will resolve, once, to the given value.
     pub fn new(value: T) -> Self {
-        Self(std::sync::Arc::new(std::sync::Mutex::new(Some(value))))
+        Self(Arc::new(Mutex::new(Some(value))))
     }
 
     /// Take the value from self.
     pub fn take(&self) -> Option<T> {
-        self.0.lock().unwrap().take()
+        self.0.lock().take()
     }
 
     /// Check if there is a value still to be resolved in self.
     pub fn is_some(&self) -> bool {
-        self.0.lock().unwrap().is_some()
+        self.0.lock().is_some()
     }
 }
 

cursive-core/src/view/view_trait.rs

@@ -31,7 +31,7 @@ impl std::error::Error for ViewNotFound {}
 /// Main trait defining a view behaviour.
 ///
 /// This is what you should implement to define a custom View.
-pub trait View: Any + AnyView + Send {
+pub trait View: Any + AnyView + Send + Sync {
     /// Draws the view with the given printer (includes bounds) and focus.
     ///
     /// This is the only *required* method to implement.

cursive-core/src/view/view_wrapper.rs

@@ -20,7 +20,7 @@ use crate::{
 /// child view).
 ///
 /// [`wrap_impl!`]: crate::wrap_impl!
-pub trait ViewWrapper: Send + 'static {
+pub trait ViewWrapper: Send + Sync + 'static {
     /// Type that this view wraps.
     type V: View + ?Sized;
 

cursive-core/src/views/canvas.rs

@@ -276,7 +276,7 @@ impl<T> Canvas<T> {
     }
 }
 
-impl<T: 'static + Send> View for Canvas<T> {
+impl<T: 'static + Send + Sync> View for Canvas<T> {
     fn draw(&self, printer: &Printer) {
         (self.draw)(&self.state, printer);
     }

cursive-core/src/views/dialog.rs

@@ -9,7 +9,7 @@ use crate::{
     views::{BoxedView, Button, DummyView, LastSizeView, TextView},
     Cursive, Printer, Vec2, With,
 };
-use std::cell::Cell;
+use parking_lot::Mutex;
 use std::cmp::{max, min};
 
 /// Identifies currently focused element in [`Dialog`].
@@ -64,7 +64,7 @@ impl crate::builder::Resolvable for DialogFocus {
 
 struct ChildButton {
     button: LastSizeView<Button>,
-    offset: Cell<Vec2>,
+    offset: Mutex<Vec2>,
 }
 
 impl ChildButton {
@@ -74,7 +74,7 @@ impl ChildButton {
     {
         ChildButton {
             button: LastSizeView::new(Button::new(label, cb)),
-            offset: Cell::new(Vec2::zero()),
+            offset: Mutex::new(Vec2::zero()),
         }
     }
 }
@@ -550,7 +550,7 @@ impl Dialog {
             let button = &mut self.buttons[button_id];
             button
                 .button
-                .on_event(event.relativized(button.offset.get()))
+                .on_event(event.relativized(*button.offset.lock()))
         };
         match result {
             EventResult::Ignored => {
@@ -644,7 +644,7 @@ impl Dialog {
             let size = button.button.size;
             // Add some special effect to the focused button
             let position = Vec2::new(offset, y);
-            button.offset.set(position);
+            *button.offset.lock() = position;
             button.button.draw(
                 &printer
                     .offset(position)
@@ -722,7 +722,7 @@ impl Dialog {
             // Now that we have a relative position, checks for buttons?
             if let Some(i) = self.buttons.iter().position(|btn| {
                 // If position fits there...
-                position.fits_in_rect(btn.offset.get(), btn.button.size)
+                position.fits_in_rect(*btn.offset.lock(), btn.button.size)
             }) {
                 return Some(self.set_focus(DialogFocus::Button(i)));
             } else if position

cursive-core/src/views/focus_tracker.rs

@@ -8,11 +8,11 @@ use crate::{
 /// Detects focus events for a view.
 pub struct FocusTracker<T> {
     view: T,
-    on_focus_lost: Box<dyn FnMut(&mut T) -> EventResult + Send>,
-    on_focus: Box<dyn FnMut(&mut T) -> EventResult + Send>,
+    on_focus_lost: Box<dyn FnMut(&mut T) -> EventResult + Send + Sync>,
+    on_focus: Box<dyn FnMut(&mut T) -> EventResult + Send + Sync>,
 }
 
-impl<T: 'static> FocusTracker<T> {
+impl<T: Send + Sync + 'static> FocusTracker<T> {
     /// Wraps a view in a new `FocusTracker`.
     pub fn new(view: T) -> Self {
         FocusTracker {
@@ -26,7 +26,7 @@ impl<T: 'static> FocusTracker<T> {
     #[must_use]
     pub fn on_focus<F>(self, f: F) -> Self
     where
-        F: 'static + FnMut(&mut T) -> EventResult + Send,
+        F: 'static + FnMut(&mut T) -> EventResult + Send + Sync,
     {
         self.with(|s| s.set_on_focus(f))
     }
@@ -35,7 +35,7 @@ impl<T: 'static> FocusTracker<T> {
     #[crate::callback_helpers]
     pub fn set_on_focus<F>(&mut self, f: F)
     where
-        F: 'static + FnMut(&mut T) -> EventResult + Send,
+        F: 'static + FnMut(&mut T) -> EventResult + Send + Sync,
     {
         self.on_focus = Box::new(f);
     }
@@ -44,7 +44,7 @@ impl<T: 'static> FocusTracker<T> {
     #[must_use]
     pub fn on_focus_lost<F>(self, f: F) -> Self
     where
-        F: 'static + FnMut(&mut T) -> EventResult + Send,
+        F: 'static + FnMut(&mut T) -> EventResult + Send + Sync,
     {
         self.with(|s| s.set_on_focus_lost(f))
     }
@@ -53,7 +53,7 @@ impl<T: 'static> FocusTracker<T> {
     #[crate::callback_helpers]
     pub fn set_on_focus_lost<F>(&mut self, f: F)
     where
-        F: 'static + FnMut(&mut T) -> EventResult + Send,
+        F: 'static + FnMut(&mut T) -> EventResult + Send + Sync,
     {
         self.on_focus_lost = Box::new(f);
     }

cursive-core/src/views/stack_view.rs

@@ -13,7 +13,6 @@ use crate::{
     views::{BoxedView, CircularFocus, Layer, ShadowView},
     Printer, Vec2, With,
 };
-use std::cell;
 use std::ops::Deref;
 
 /// Simple stack of views.
@@ -26,7 +25,7 @@ pub struct StackView {
     // and therefore need redrawing.
     // TODO: this is broken! Transparent views could change their content and lead to weirdness.
     // Instead, just rely on buffered backend.
-    bg_dirty: cell::Cell<bool>,
+    bg_dirty: std::sync::atomic::AtomicBool,
 }
 
 // This is a poor man's optional parameter, or kinda builder pattern.
@@ -310,7 +309,7 @@ impl StackView {
         StackView {
             layers: Vec::new(),
             last_size: Vec2::zero(),
-            bg_dirty: cell::Cell::new(true),
+            bg_dirty: std::sync::atomic::AtomicBool::new(true),
         }
     }
 
@@ -514,7 +513,7 @@ impl StackView {
     ///
     /// If the given position is out of bounds.
     pub fn remove_layer(&mut self, position: LayerPosition) -> Box<dyn View> {
-        self.bg_dirty.set(true);
+        self.set_dirty();
         let i = self.get_index(position).unwrap();
         self.layers
             .remove(i)
@@ -526,9 +525,23 @@ impl StackView {
             .unwrap()
     }
 
+    fn set_dirty(&self) {
+        self.bg_dirty
+            .store(true, std::sync::atomic::Ordering::Relaxed);
+    }
+
+    fn undirty(&self) {
+        self.bg_dirty
+            .store(false, std::sync::atomic::Ordering::Relaxed);
+    }
+
+    fn is_dirty(&self) -> bool {
+        self.bg_dirty.load(std::sync::atomic::Ordering::Relaxed)
+    }
+
     /// Remove the top-most layer.
     pub fn pop_layer(&mut self) -> Option<Box<dyn View>> {
-        self.bg_dirty.set(true);
+        self.set_dirty();
         self.layers
             .pop()
             .map(|child| child.view)
@@ -621,7 +634,7 @@ impl StackView {
         match child.placement {
             Placement::Floating(_) => {
                 child.placement = Placement::Floating(position);
-                self.bg_dirty.set(true);
+                self.set_dirty();
             }
             Placement::Fullscreen => (),
         }
@@ -642,15 +655,15 @@ impl StackView {
     /// You probably just want to call draw()
     pub fn draw_bg(&self, printer: &Printer) {
         // If the background is dirty draw a new background
-        if self.bg_dirty.get() {
+        if self.is_dirty() {
             for y in 0..printer.size.y {
                 printer.with_style(PaletteStyle::Background, |printer| {
                     printer.print_hline((0, y), printer.size.x, " ");
                 });
             }
 
             // set background as clean, so we don't need to do this every frame
-            self.bg_dirty.set(false);
+            self.undirty();
         }
     }
 
@@ -732,7 +745,7 @@ impl View for StackView {
 
     fn on_event(&mut self, event: Event) -> EventResult {
         if event == Event::WindowResize {
-            self.bg_dirty.set(true);
+            self.set_dirty();
         }
 
         // Use the stack position iterator to get the offset of the top layer.

cursive-core/src/views/tracked_view.rs

@@ -1,29 +1,29 @@
 use crate::view::{View, ViewWrapper};
 use crate::Printer;
 use crate::Vec2;
-use std::cell::Cell;
+use parking_lot::Mutex;
 
 /// Wrapper around a view that remembers its position.
 pub struct TrackedView<T> {
     /// Wrapped view.
     pub view: T,
     /// Last position the view was located.
-    offset: Cell<Vec2>,
+    offset: Mutex<Vec2>,
 }
 
 new_default!(TrackedView<T: Default>);
 
 impl<T> TrackedView<T> {
     /// Return the last offset at which the view was drawn.
     pub fn offset(&self) -> Vec2 {
-        self.offset.get()
+        *self.offset.lock()
     }
 
     /// Creates a new `TrackedView` around `view`.
     pub fn new(view: T) -> Self {
         TrackedView {
             view,
-            offset: Cell::new(Vec2::zero()),
+            offset: Mutex::new(Vec2::zero()),
         }
     }
 
@@ -34,7 +34,7 @@ impl<T: View> ViewWrapper for TrackedView<T> {
     wrap_impl!(self.view: T);
 
     fn wrap_draw(&self, printer: &Printer) {
-        self.offset.set(printer.offset);
+        *self.offset.lock() = printer.offset;
         self.view.draw(printer);
     }
 }